Search Program on this blog

Friday 6 November 2015

Write a function called moving_average that takes a scalar called x as an input argument and returns a scalar. The value it returns depends not only on the input but also on previous inputs to this same function when the function is called repeatedly. That returned value is a “moving average” of those inputs. The function uses a “buffer” to hold previous inputs, and the buffer can hold a maximum of 25 inputs. Specifically, the function must save the most recent 25 inputs in a vector (the buffer) that is a persistent variable inside the function. Each time the function is called, it copies the input argument into an element of the buffer. If there are already 25 inputs stored in the buffer, it discards the oldest element and saves the current one in the buffer. After it has stored the input in the buffer, it returns the mean of all the elements in the buffer. Thus, for each of the first 24 calls to the function, the function uses only the inputs it has received so far to determine the average (e.g., the first call simply returns x, the second call averages x and the input from the first call, etc.), and after that, it returns the average of the most recent 25 inputs.

function mean = moving_average(x)
persistent first;
persistent buffer;
persistent counter;
if isempty(buffer) && isempty(counter)
    buffer=x;
    counter=1;
    first=x;
elseif counter<25
    buffer=buffer+x;
    counter=counter+1;
    first=[first x];
elseif counter==25
    buffer=buffer-first(1)+x;
    first = [first(2:counter) x];
end
mean = buffer/counter;

Write a function called movies that takes the starting times of two movies, hr1, hr2, min1, min2, and their durations, durmin1, durmin2, as its input arguments and decides whether we can binge and watch both. The criteria are that they must not overlap and that we are not going to wait more than 30 minutes between the end of one and the beginning of the next. It returns true if the criteria are both met and returns false otherwise. You may assume that movie start times are always after 1 pm and before midnight. You may also assume that the first one starts earlier. The order of the input arguments is: hr1, min1, durmin1, hr2, min2, durmin2.

function watch = movies(hr1,min1,durmin1,hr2,min2,~)
diff = (hr2*60+min2)-(hr1*60+min1+durmin1);
if hr1<=hr2
    if diff>=0
        if diff<=30
            watch=1';
        elseif diff>30
            watch=0;
        end
    elseif diff<0
        watch=0;
    end
else
    watch =0;
end

Write a function called older that takes as its input arguments six positive scalar integers: y1, m1, d1, y2, m2, d2, in that order, representing the birthdates of two persons. The variables that start with y stand for the year, m for the month and d for the day. The variables that end in 1 correspond to the first person, while those that end in 2 correspond to the second person. The function returns 1 if the first person is older, 0 if they have the same age, and -1 if the first person is younger. You do not need to check whether the inputs have appropriate values. For example, you may assume that both m1 and m2 are positive integers that are less than 13 and that the day numbers fit with their months.

function out = older(y1,m1,d1,y2,m2,d2)
if m2>0 && m2<13
    if m2==1 || m2==3 || m2==5 || m2==7 || m2==8 || m2==10 || m2==12
        if d2>0 && d2<32
            flag=1;
        else
            flag=0;
        end
    elseif m2==4 || m2==6 || m2==9 || m2==11
        if d2>0 && d2<31
            flag=1;
        else
            flag=0;
        end
    elseif m2==2
        if mod(y2,4)==0 && (mod(y2,400)==0 || mod(y2,100)~=0) && d2<=29 && d2>0
            flag=1;
        elseif d2>0 && d2<=28
            flag=1;
        else
            flag=0;
        end
    end
else
    return;
end
if m1>0 && m1<13
    if m1==1 || m1==3 || m1==5 || m1==7 || m1==8 || m1==10 || m1==12
        if d1>0 && d1<32
            f=1;
        else
            f=0;
        end
    elseif m1==4 || m1==6 || m1==9 || m1==11
        if d1>0 && d1<31
            f=1;
        else
            f=0;
        end
    elseif m1==2
        if mod(y1,4)==0 && (mod(y1,400)==0 || mod(y1,100)~=0) && d1<=29 && d1>0
            f=1;
        elseif d2>0 && d2<=28
            f=1;
        else
            f=0;
        end
    end
else
    return;
end
if y1<y2
    out=1;
elseif y1==y2
    if m1<m2
        out=1;
    elseif m1==m2
        if d1<d2
            out=1;
        elseif d1==d2
            out=0;
        else
            out=-1;
        end
    else
        out=-1;
    end
else
    out=-1;
end

Write a function called classify that takes one input argument x. That argument will have no more than two dimensions. If x is an empty matrix, the function returns -1. If x is a scalar, it returns 0. If x is a vector, it returns 1. Finally, if x is none of these, it returns 2. Do not use the built-in functions isempty, isscalar, or isvector.

function out = classify(x)
[n m] = size(x);
if nargin==1
    if n==0 || m==0
        out=-1;
    elseif n==1 && m==1
        out=0;
    elseif n==1 && m>1
        out=1;
    elseif m==1 && n>1
        out=1;
    %elseif n>1 && m>1
        %out=1;
    else
        out=2;
    end
else
    out=2;
end

Write a function called sort3 that takes three scalar arguments. It uses if-statements, possibly nested, to return the three values of these arguments in a single row-vector in increasing order (or more precisely, non-decreasing order), i.e., element one of the output vector equals the smallest input argument and element three of the output vector equals the largest input argument. NOTE: Your function may not use any built-in functions, e.g., sort.

function row = sort3(a,b,c)
if a>=b && a>=c
    if b>=c
        row = [c b a];
    elseif b<=c
        row = [b c a];
    end
elseif b>=a && b>=c
    if a>=c
        row = [c a b];
    elseif a<=c
        row = [a c b];
    end
elseif c>=a && c>=b
    if a>=b
        row = [b a c];
    elseif a<=b
        row = [a b c];
    end
end

Write a function called letter_grade that takes a positive integer called score as its input argument and returns a letter grade according to the following scale: A: 91 and above; B: 81-90; C: 71-80; D: 61-70; F: below 61. Remember that to assign a letter to a variable, you need to put it in single quotes, as in: grade = 'A'.

function grade = letter_grade(score)
if score>=91
    grade = 'A';
elseif score>=81 && score<=90
    grade = 'B';
elseif score>=71 && score<=80
    grade = 'C';
elseif score>=61 && score<=70
    grade = 'D';
elseif score<61
    grade = 'F';
end

Write a function called generationXYZ that takes as its only input argument one positive integer specifying the year of birth of a person and returns as its only output argument the name of the generation that the person is part of ('X', 'Y', or 'Z ') according to the table below. For births before 1966, return 'O' for Old and for births after 2012, return 'K' for Kid. Remember that to assign a letter to a variable, you need to put it in single quotes

function gen = generationXYZ(year)
if year<1966
    gen = 'O';
elseif year>=1966 && year<=1980
    gen = 'X';
elseif year>=1981 && year<=1999
    gen = 'Y';
elseif year>=2000 && year<=2012
    gen = 'Z';
elseif year> 2012
    gen = 'K';
end

Write a function called checkerboard that takes as input two positive integer scalars, n and m, in that order. The function must create and return board, which is an n-­‐by-­‐m matrix. Every element of board is either 0 or 1. The first element, board(1,1) is 1. No direct neighbors in the matrix, vertically or horizontally, can be equal. That is, a 1 element cannot have 1 immediately preceding or following it in the same row or column.

function board = checkerboard(n,m)
board = zeros(n,m);
board(1:2:n,1:2:m)=1;
board(2:2:n,2:2:m)=1;

Write a function called identity that creates a square identity matrix, which is a matrix whose elements are 0 except for the elements on the diagonal (from top left to bottom right) which have a value of 1. The diagonal consists of those elements whose row and column indexes are the same: (1,1), (2,2), etc. The function takes one positive integer input argument, which is the size of the matrix, and returns the matrix itself as an output argument. For example, identity(4) must return a 4-­‐by-­‐4 identity matrix. You are not allowed to use the built-­‐in eye or diag functions. (Hint: you can index into a matrix with a single index and MATLAB will handle it as if it was a vector using column-­‐major order.)

function M = identity(n)
M = zeros(n);
M(1:n+1:end)=1;

Write a function called mtable that returns mt an n-­‐by-­‐m matrix corresponding to the multiplication table (n is the first and m is the second input argument). That is, the element of mt at row ii and column jj equals to ii*jj. The function also has a second output, s, a scalar that equals the sum of all the elements of mt.

function [mt s] = mtable(n,m)
for i=1:n
    for j=1:m
        mt(i,j) = i*j;
    end
end
s = sum(sum(mt));

Write a function called quadrants that takes as its input argument a scalar integer named n. The function returns Q, a 2n-­‐by-­‐2n matrix. Q consists of four n-­‐by-­‐n submatrices. The elements of the submatrix in the top left corner are all 1s, the elements of the submatrix at the top right are 2s, the elements in the bottom left are 3s, and the elements in the bottom right are 4s.

function Q = quadrants(n)
A(1:n,1:n)=1;
B(1:n,1:n)=2;
C(1:n,1:n)=3;
D(1:n,1:n)=4;
Q = [A B;C D];

Write a function called randomness that takes three input arguments: limit, n, and m, in that order. The function returns an n-­‐by-­‐m matrix of uniformly distributed random integers between 1 and limit inclusive. You are not allowed to use randi, but you can use rand. You will also find the built-­‐in function floor useful for obtaining integers. To make sure that your result is indeed uniformly distributed, test the output of the function by using the built-­‐in function hist, which plots a histogram.

function M = randomness(limit,n,m)
M = floor(1+ rand(n,m)*limit);
hist(M);