Assembly-Language Interview Questions with Answers

MATLAB (Matrix Laboratory) is a high-level programming language and interactive environment developed by MathWorks. It is widely used for numerical computing, matrix manipulations, data analysis, visualization, and algorithm development.

Variables in MATLAB are used to store data values. They are dynamically typed, which means you do not need to explicitly declare their data type or allocate memory before using them.

A matrix is the fundamental data structure in MATLAB. MATLAB is designed to treat all variables as multi-dimensional arrays or matrices, which allows for highly optimized mathematical operations.

A row vector can be created by separating element values with spaces or commas inside square brackets:

a = [1 2 3 4];

A column vector is created by separating element values with semicolons inside square brackets:

a = [1; 2; 3; 4];

Placing a semicolon (;) at the end of a line suppresses output display in the Command Window, allowing statements to execute quietly in the background.

Comments are initiated with the percent symbol (%). Anything following it on the same line is ignored by the compiler:

% This is a single-line comment in MATLAB

A script is a standard text file with a .m extension containing a sequential list of MATLAB commands. Running the script executes these statements as if they were typed directly into the command line.

A function is a separate block of code that accepts parameters, runs isolated computations in its own workspace, and returns specific output variables.

Scripts operate within the global base workspace, sharing variable declarations directly.Functions maintain an isolated, temporary local workspace that clears automatically when execution ends.

Functions are declared using the function keyword, mapping outputs, the function name, and inputs:

function y = squareNum(x)
    y = x^2;
end

Indexing refers to accessing individual elements or sub-sections of arrays and matrices. MATLAB uses 1-based indexing, meaning the first element in any array starts at index 1.

The colon operator (:) generates sequences of values and is useful for creating loops or slicing index matrices:

% Generate sequence from 1 to 5
seq = 1:5;

A cell array is a dynamic database structure containing indexed buckets called cells, where each individual cell can store different data types, structures, and dimensions.

Structures group data logically using named parameter fields, letting you map associated attributes to a single object:

person.name = 'John';
person.age = 30;

Vectorization is the process of replacing explicit loops (like for and while) with matrix algebra equations. Since MATLAB operations are highly optimized for matrices, vectorized code runs significantly faster.

A Value class creates a completely new copy of an object when it is assigned or passed to a function. A Handle class passes objects by reference, meaning modifications in one location affect all variables referencing that instance.

A sparse matrix is an optimized matrix structure that only stores elements with non-zero values. This saves memory and calculation overhead when working with large matrices containing mostly zeroes.

Simulink is a block-diagram, visual programming environment integrated directly with MATLAB. It is used for modeling, simulating, and analyzing multi-domain dynamic and embedded control systems.

A MEX file (MATLAB Executable) is a compiled C, C++, or Fortran subroutine that runs directly inside MATLAB, allowing you to optimize computationally heavy tasks.

Element-wise operations apply an operation to each element individually, using the dot (.) operator before the arithmetic symbol:

A = [1 2; 3 4];
B = A .* A;  % element-wise multiplication

The basic syntax for a for loop is:

for i = 1:10
    disp(i);
end

Use the plot function to create 2D line plots:

x = 0:0.1:2*pi;
y = sin(x);
plot(x, y);
title('Sine Wave');
xlabel('x');
ylabel('sin(x)');

Use the det function:

A = [1 2; 3 4];
detA = det(A);

Use the inv function:

A = [1 2; 3 4];
invA = inv(A);

Use the eig function:

A = [1 2; 3 4];
eigA = eig(A);

Use fopen, fscanf, and fclose:

fileID = fopen('data.txt', 'r');
data = fscanf(fileID, '%f');
fclose(fileID);

Use fopen, fprintf, and fclose:

fileID = fopen('output.txt', 'w');
fprintf(fileID, 'Value: %f\n', 3.14);
fclose(fileID);

Use the replace function:

str = 'Hello, World!';
newStr = replace(str, 'World', 'MATLAB');

Use rand for uniform distribution or randn for normal distribution:

A = rand(3);  % 3x3 random matrix

ones creates an array of all ones:

A = ones(2,3);

zeros creates an array of all zeros:

A = zeros(4,1);

Use the .^ operator:

x = 1:10;
y = x.^2;  % element-wise power

Logical indexing uses a logical array (true/false) to select elements from another array:

A = [1 2; 3 4];
B = A > 2;  % logical matrix

Use row and column indices inside parentheses:

A = [1 2; 3 4];
B = A(2,1);  % access element

Use the colon operator to select all rows for a given column:

A = [1 2 3; 4 5 6];
B = A(:, 2);  % second column

Use the colon operator to select all columns for a given row:

A = [1 2 3; 4 5 6];
B = A(1, :);  % first row

Use ranges of rows and columns:

A = [1 2; 3 4];
B = A(1, 1);  % single element

Use the size function:

A = [1 2; 3 4];
sizeA = size(A);

length returns the largest dimension of the array:

A = [1 2; 3 4];
lenA = length(A);  % returns max dimension

Use the classdef block to define properties and methods:

classdef MyClass
    properties
        Value
    end
    methods
        function obj = MyClass(val)
            obj.Value = val;
        end
        function displayValue(obj)
            disp(obj.Value);
        end
    end
end

A handle class (subclass of handle) passes objects by reference:

% Example of handle class
classdef MyHandle < handle
    properties
        Data
    end
end

A value class (default) creates independent copies when assigned:

% Value class example
classdef MyValue
    properties
        Data
    end
end

Enumerations define a set of named constants:

% Enumeration
classdef Status < int32
    enumeration
        Inactive (0)
        Active (1)
    end
end

Live scripts (.mlx) combine code, output, and formatted text in a single interactive document.

% Live script with interactive controls
% slider
x = linspace(0, 10, 100);
y = sin(x);
plot(x, y);

Anonymous functions are one-liner functions defined using @:

% Using anonymous function
f = @(x) x.^2 + 3*x - 5;
val = f(2);  % 4+6-5 = 5

A nested function is defined inside another function and can access its parent's workspace:

% Nested function
function outer
    function inner
        disp('Inner');
    end
    inner();
end

A function that calls itself:

% Recursive function
function f = factorialRec(n)
    if n <= 1
        f = 1;
    else
        f = n * factorialRec(n-1);
    end
end

Global variables are declared with global and are shared across all functions:

% Global variable
global GLOBAL_VAR;
GLOBAL_VAR = 42;

Persistent variables retain their value between function calls:

% Persistent variable
function count = myCounter()
    persistent cnt;
    if isempty(cnt)
        cnt = 0;
    end
    cnt = cnt + 1;
    count = cnt;
end

varargin captures any number of input arguments:

% Using varargin
function printArgs(varargin)
    for i = 1:length(varargin)
        disp(varargin{i});
    end
end

nargin returns the number of input arguments passed to the function:

% Using nargin
function myFunc(a, b)
    if nargin < 2
        b = 0;
    end
    disp(a + b);
end

nargout returns the number of output arguments requested by the caller:

% Using nargout
function [out1, out2] = twoOutputs()
    out1 = 1;
    out2 = 2;
end

Use try and catch blocks:

% Error handling
try
    x = 1 / 0;
catch ME
    disp(ME.message);
end

Use the warning function:

% Warning
warning('This is a warning message');

Use indexing to create multiple structure elements:

% Struct array
people(1).name = 'Alice';
people(1).age = 25;
people(2).name = 'Bob';
people(2).age = 30;

Use curly braces to retrieve contents:

% Cell array
C = {'text', [1 2 3], 42};
disp(C{2});  % display array

Tables store column-oriented data with variable names:

% Table
T = table([1;2], {'A';'B'}, 'VariableNames', {'Num', 'Letter'});

Use the datetime type:

% Date and time
t = datetime('now');
disp(t);

Use the timer object:

% Timer
t = timer('TimerFcn', @(x,y) disp('Timer triggered'), 'StartDelay', 1);
start(t);

Use ode45 or other solvers:

% ODE solver
[t, y] = ode45(@(t,y) t*y, [0 1], 1);

Fast Fourier Transform (fft) computes the discrete Fourier transform:

% FFT
x = 0:0.01:10;
y = sin(2*pi*5*x);
Y = fft(y);

Use polyfit and polyval:

% Curve fitting
x = [1 2 3 4];
y = [2 4 6 8];
p = polyfit(x, y, 1);  % linear fit

Use figure and uicontrol functions:

% GUI - simple figure
f = figure('Name', 'My Figure');
uicontrol('Style', 'pushbutton', 'String', 'Click Me', 'Callback', @(src,evt) disp('Button pressed'));

App Designer is a modern environment for building apps with a drag-and-drop interface.

% App Designer – export function
methods (Access = private)
    function myAppFunction(app)
        % code
    end
end

Use readtable or xlsread:

% Import data
data = readtable('data.xlsx');

Use writetable or xlswrite:

% Export data
writetable(T, 'output.xlsx');

Use save:

% Save variables
save('workspace.mat', 'a', 'b');

Use load:

% Load variables
load('workspace.mat');

Use clear:

% Clear workspace
clear all;

Use backslash (\) operator or fitlm:

% Multiple linear regression
X = [ones(10,1) randn(10,2)];
b = X  y;

Use polyval:

% Polynomial evaluation
p = [1 0 5];
val = polyval(p, 2);  % 1*4 + 0*2 + 5 = 9

Use interp1 or spline:

% Interpolation
x = 1:10;
y = rand(1,10);
xi = 1:0.5:10;
yi = interp1(x, y, xi, 'spline');

Use integral:

% Integration
f = @(x) x.^2;
q = integral(f, 0, 1);  % 1/3

Use diff with symbolic variables:

% Differentiation
syms x;
df = diff(x^3);  % 3*x^2

Use solve:

% Symbolic solving
syms x;
sol = solve(x^2 - 4 == 0, x);

Use laplace:

% Laplace transform
syms t;
laplace(t^2);

Use ilaplace:

% Inverse Laplace
syms s;
ilaplace(1/s^2);

Use ztrans:

% Z-transform
syms n;
ztrans(2^n);

Use butter, cheby1, etc.:

% Filter design
[b, a] = butter(4, 0.3);

Use the pid function:

% PID controller
Kp = 1; Ki = 0.1; Kd = 0.05;
C = pid(Kp, Ki, Kd);

Use sim function:

% Simulink model – run simulation
sim('myModel');

Open a parallel pool and use parfor:

% Parallel computing
parpool;
parfor i = 1:10
    disp(i);
end

Use gpuArray and operations on it:

% GPU computing
A = gpuArray(rand(1000));
B = A .* A;

Use imrotate:

% Image processing
I = imread('image.jpg');
J = imrotate(I, 45);

Use filter:

% Signal processing
y = filter(b, a, x);

Use fitcecoc (multi-class) or other classifiers:

% Classification
mdl = fitcecoc(X, Y);

Use fitlm or fitrensemble:

% Regression
mdl = fitlm(X, Y);

Use feedforwardnet and train:

% Neural network
net = feedforwardnet(10);
net = train(net, X, Y);

1. Vectorize operations whenever possible.
2. Preallocate arrays before loops.
3. Use meaningful variable names.
4. Comment your code clearly.
5. Use profiler to find bottlenecks.