Updated Discussions

Directed and Undirected Graphs - MATLAB & Simulink

Madson
Last activity about 10 hours ago

How to learn Matlab - from begginer to expert

Hi, what’s the best way to learn MATLAB, Simulink, and Simscape? Do you recommend a learning path? I work in the Electrical & Electronics area for automotive systems.

Team Creative Coders

Vasilis Bellos
Last activity about 10 hours ago

Visualizing the Solution to The Bridges of Nedsburg

The Cody Contest 2025 is underway, and it includes a super creative problem group which many of us have found fascinating. The central theme of the problems, expertly curated by @Matt Tearle, humorously revolves around the whims of the capricious dictator Lord Ned, as he goes out of his way to complicate the lives of his subjects and visitors alike. We cannot judge whether or not there's any truth to the rumors behind all the inside jokes, but it's obvious that the team had a lot of fun creating these; and we had even more fun solving them.

Today I want to showcase a way of graphically solving and visualizing one of those problems which I found very elegant, The Bridges of Nedsburg.

To briefly reiterate the problem, the number of islands and the arrangement of bridges of the city of Nedsburg are constantly changing. Lord Ned has decided to take advantage of this fact by charging visitors with an increasingly expensive n-bridge pass which allows them to cross up to n bridges in one journey. Given the Connectivity Matrix C, we are tasked with calculating the minimum n needed so that there is a path from every island to every other island in n steps or fewer.

Matt kindly provided us with some useful bit of math in the description detailing how to calculate the way to get from one island to another in an number of m steps. However, he has also hidden an alternative path to the solution in plain sight, in one of the graphs he provided. This involves the extremely useful and versatile object digraph, representing directed graphs, which have directional edges connecting the nodes. Here's some further great documentation on the topic for those who are interested in learning more about it:

Graph and Digraph Classes - MATLAB

Let's start using this object to explore a graphical solution to Lord Ned's conundrum. We will use the unit tests included in the problem to visualize the solution. We can retrieve the connectivity matrix for each case using the following function:

function C = getConnectivityMatrix(unit_test)
% Number or islands and arrangement
switch unit_test
    case 1
        m = 3; idx = [3;4;8];
    case 2
        m = 3; idx = [3;4;7;8];
    case 3
        m = 4; idx = [2;7;8;10;13];
    case 4
        m = 4; idx = [4;5;7;8;9;14];
    case 5
        m = 5; idx = [5;8;11;12;14;18;22;23];
    case 6
        m = 5; idx = [2;5;8;14;20;21;24];
    case 7
        m = 6; idx = [3;4;7;11;18;23;24;26;30;32];
    case 8
        m = 6; idx = [3;11;12;13;18;19;28;32];
    case 9
        m = 7; idx = [3;4;6;8;13;14;20;21;23;31;36;47];
    case 10
        m = 7; idx = [4;11;13;14;19;22;23;26;28;30;34;35;37;38;45];
    case 11
        m = 8; idx = [2;4;5;6;8;12;13;17;27;39;44;48;54;58;60;62];
    case 12
        m = 8; idx = [3;9;12;20;24;29;30;31;33;44;48;50;53;54;58];
    case 13
        m = 9; idx = [8;9;10;14;15;22;25;26;29;33;36;42;44;47;48;50;53;54;55;67;80];
    case 14
        m = 9; idx = [8;10;22;32;37;40;43;45;47;53;56;57;62;64;69;70;73;77;79];
    case 15
        m = 10; idx = [2;5;8;13;16;20;24;27;28;36;43;49;53;62;71;75;77;83;86;87;95];
    case 16
        m = 10; idx = [4;9;14;21;22;35;37;38;44;47;50;51;53;55;59;61;63;66;69;76;77;84;85;86;90;97];
end
C = zeros(m);
C(idx) = 1;
end

The case in the example refets to unit test case 2.

unit_test = 2;
C = getConnectivityMatrix(unit_test);
disp(C)
     0     1     1
     0     0     1
     1     0     0

We now calculate the digraph object D, and visualize it using its corresponding plot method:

D = digraph(C);

figure

p = plot(D,'LineWidth',1.5,'ArrowSize',10);

This is the same as the graph provided in the example. Another very useful method of digraph is shortestpath. This allows us to calculate the path and distance from one single node to another. For example:

% Path and distance from node 1 to node 2
[path12,dist12] = shortestpath(D,1,2);
fprintf('The shortest path from island %d to island %d is: %s. The minimum number of steps is: n = %d\n', 1, 2, join(string(path12), ' -> '),dist12)
The shortest path from island 1 to island 2 is: 1 -> 2. The minimum number of steps is: n = 1
% Path and distance from node 2 to node 1
[path21,dist21] = shortestpath(D,2,1);
fprintf('The shortest path from island %d to island %d is: %s. The minimum number of steps is: n = %d\n', 2, 1, join(string(path21), ' -> '),dist21)
The shortest path from island 2 to island 1 is: 2 -> 3 -> 1. The minimum number of steps is: n = 2

We can visualize these using the highlight method of the graph plot:

figure

p = plot(D,'LineWidth',1.5,'ArrowSize',10);

highlight(p,path12,'EdgeColor','r','NodeColor','r','LineWidth',2)

highlight(p,path21,'EdgeColor',[0 0.8 0],'LineWidth',2)

But that's not all! digraph can also provide us with a matrix of the distances d, i.e. the steps needed to travel from island i to island j, where i and j are the rows and columns of d respectively. This is accomplished by using its distances method. The distance matrix can be visualized as:

d = distances(D);

figure

% Using pcolor w/ appending matrix workaround for convenience

pcolor([d,d(:,end);d(end,:),d(end,end)]);

% Alternatively you can use imagesc(d), but you'll have to recreate the grid manually

axis square

set(gca,'YDir','reverse','XTick',[],'YTick',[])

[X,Y] = meshgrid(1:height(d));

text(X(:)+0.5,Y(:)+0.5,string(d(:)),'FontSize',11)

colormap(interp1(linspace(0,1,4), [1 1 1; 0.7 0.9 1; 0.6 0.7 1; 1 0.3 0.3], linspace(0,1,8)))

clim([-0.5 7+0.5])

This confirms what we saw before, i.e. you need 1 step to go from island 1 to island 2, but 2 steps for vice versa. It also confirms that the minimum number of steps n that you need to buy the pass for is 2 (which also occurs for traveling from island 3 to island 2). As it's not the point of the post to give the full solution to the problem but rather present the graphical way of visualizing it I will not include the code of how to calculate this, but I'm sure that by now it's reduced to a trivial problem which you have already figured out how to solve.

That being said, now that we have the distance matrix, let's continue with the visualizations. First, let's plot the corresponding paths for each of these combinations:

figure

tiledlayout(size(C,1),size(C,2),'TileSpacing','tight','Padding','tight');

for i = 1:size(C,1)

for j = 1:size(C,2)

nexttile

p = plot(D,'ArrowSize',10);

highlight(p,shortestpath(D,i,j),'EdgeColor','r','NodeColor','r','LineWidth',2);

lims = axis;

text(lims(1)+diff(lims(1:2))*0.05,lims(3)+diff(lims(3:4))*0.9,sprintf('n = %d',d(i,j))) % Or use from shortest path

end

This allows us to go from the distance matrix to visualizing the paths and number of steps for each corresponding case. Things are rather simple for this 3-island example case, but evil Lord Ned is just getting started. Let's now try to solve to problem for all provided unit test cases:

% Cell array of connectivity matrices
C = arrayfun(@getConnectivityMatrix,1:16,'UniformOutput',false);
% Cell array of corresponding digraph objects
D = cellfun(@digraph,C,'UniformOutput',false);
% Cell array of corresponding distance matrices
d = cellfun(@distances,D,'UniformOutput',false);
% id of solutions: Provided as is to avoid handing out the code to the full solution
id = [2, 2, 9, 3, 4, 6, 16, 4, 44, 43, 33, 34, 7, 18, 39, 2];

First, let's plot the distance matrix for each case:

figure

tiledlayout('flow','TileSpacing','compact','Padding','compact');

% Vary this to plot different combinations of cases

plot_cases = 1:numel(C);

for i = plot_cases

nexttile

pcolor([d{i},d{i}(:,end);d{i}(end,:),d{i}(end,end)]);

axis square

set(gca,'YDir','reverse','XTick',[],'YTick',[])

title(sprintf('Case %d',i),'FontWeight','normal','FontSize',8)

end

c = colorbar('Ticks',0:7,'TickLength',0,'Limits',[-0.5 7+0.5],'FontSize',8);

c.Layout.Tile = 'East';

c.Label.String = 'Number of Steps';

c.Label.FontSize = 8;

colormap(interp1(linspace(0,1,4), [1 1 1; 0.7 0.9 1; 0.6 0.7 1; 1 0.3 0.3], linspace(0,1,8)))

clim(findobj(gcf,'type','axes'),[-0.5 7+0.5])

We immediately notice some inconsistencies, perhaps to be expected of the eccentric and cunning dictator. Things are pretty simple for the configurations with a small number of islands, but the minimum number of steps n can increase sharply and disproportionally to the additional number of islands. Cases 8 and 9 in particular have a particularly large n (relative to their grid dimensions), and case 14 has the largest n, almost double that of case 16 despite the fact that the latter has one extra island.

To visualize how this is possible, let's plot the path corresponding to the largest n for each case (though note that there might be multiple possible paths for each case):

figure

tiledlayout('flow','TileSpacing','tight','Padding','tight');

for i = plot_cases

nexttile

% Changing the layout to circular so we can better visualize the paths

p = plot(D{i},'ArrowSize',10,'Layout','Circle');

% Alternatively we could use the XData and YData properties if the positions of the islands were provided

axis([-1.5 1.5 -1.5 1.75])

[row,col] = ind2sub(size(d{i}),id(i));

highlight(p,shortestpath(D{i},row,col),'EdgeColor','r','NodeColor','r','LineWidth',2);

lims = axis;

text(lims(1)+diff(lims(1:2))*0.05,lims(3)+diff(lims(3:4))*0.9,sprintf('n = %d',d{i}(row,col)),'HorizontalAlignment','Left')

end

And busted! Unraveled! Exposed! Lord Ned has clearly been taking advantages of the tectonic forces by instructing his corrupt civil engineer lackeys to design the bridges to purposely force the visitors to go around in circles in order to drain them of their precious savings. In particular, for cases 8 and 9, he would have them go through every single island just to get from one island to another, whereas for case 14 they would have to visit 8 of the 9 islands just to get to their destination. If that's not diabolical then I don't know what is!

Ned jokes aside, I hope you enjoyed this contest just as much as I did, and that you found this article useful. I look forward to seeing more creative problems and solutions in the future.

Team Creative Coders

Chen Lin
Last activity about 11 hours ago

Introduce Yourself to the Team Creative Coders! 👋

Hey Creative Coders! 😎

Let’s get to know each other. Drop a quick intro below and meet your teammates! This is your chance to meet teammates, find coding buddies, and build connections that make the contest more fun and rewarding!

You can share:

Your name or nickname
Where you’re from
Your favorite coding topic or language
What you’re most excited about in the contest

Let’s make Team Creative Coders an awesome community—jump in and say hi! 🚀

Athi
Last activity about 15 hours ago

Solving Systematically The Clueless - Lord Ned in the Game Room

The toughest problem in the Cody Contest 2025 is Clueless - Lord Ned in the Game Room. Thank you Matt Tearle for such as wonderful problem. We can approach this clueless(!) tough problem systematically.

Initialize knowledge Matrix

Based on the hints provided in the problem description, we can initialize a knowledge matrix of size n*3 by m+1. The rows of the knowledge matrix represent the different cards and the columns represent the players. In the knowledge matrix, the first n rows represent category 1 cards, the next n rows, category 2 and the next category 3. We can initialize this matrix with zeros. On the go, once we know that a player holds the card, we can make that entry as 1 and if a player doesn't have the card, we can make that entry as -1.

yourcards processing

These are cards received by us.

In the knowledge matrix, mark the entries as 1 for the cards received. These entries will be the some elements along the column pnum of the knowledge matrix.
Mark all other entries along the column pnum as -1, as we don't receive other cards.
Mark all other entries along the rows corresponding to the received cards as -1, as other players cannot receive the cards that are with us.

commoncards processing

These are the common cards kept open.

In the knowledge matrix, mark the entries as 1 for the common cards. These entries will be some elements along the column (m+1) of the knowledge matrix.
Mark all other entries along the column (m+1) as -1, as other cards are not common.
Mark all other entries along the rows corresponding to the common cards as -1, as other players cannot receive the cards that are common.

Result -1 processing

In the turns input matrix, the result (5th column) value -1 means, the corresponding player doesn't have the 3 cards asked.

Find all the rows with result as -1.
For those corresponding players (1st element in each row of turns matrix), mark -1 entries in the knowledge matrix for those 3 absent cards.

pnum turns processing

These are our turns, so we get definite answers for the asked cards. Make sure to traverse only the rows corresponding to our turn.

The results with -1 are already processed in the previous step.
The results other than -1 means, that particular card is present with the asked player. So mark the entry as 1 for the corresponding player in the knowledge matrix.
Mark all other entries along the row corresponding to step 2 as -1, as other players cannot receive this card.

Result 0 processing

So far, in the yourcards processing, commoncards processing, result -1 processing and pnum turns processing, we had very straightforward definite knowledge about the presence/absence of the card with a player. This step onwards, the tricky part of the problem begins.

result 0 means, any one (or more) of the asked cards are present with the asked player. We don't know exactly which card.

For the asked player, if we have a definite no answer (-1 value in the knowledge matrix) for any two of the three asked cards, then we are sure about the card that is present with the player.
Mark the entry as 1 for the definitely known card for the corresponding player in the knowledge matrix.
Mark all other entries along the row corresponding to step 2 as -1, as other players cannot receive this card.

Cards per Player processing

Based on the number of cards present in the yourcards, we know the ncards, the number of cards per player.

Check along each column of the knowledge matrix, that is for each player.

If the number of ones (definitely present cards) is equal to ncards, we can make all other entries along the column as -1, as this player cannot have any other card.
If the sum of number of ones (definitely present cards) and the number of zeros (unknown cards) is equal to ncards, we can (i) mark the zero entries as one, as the unknown cards have become definitely present cards, (ii) mark all other entries along the column as -1, as other players cannot have any other card.

Category-wise cards checking

For each category, we must get a definite card to be present in the envelope.

In each category (For every group of n rows of knowledge matrix), check for a row with all -1s. That is a card which is definitely not present with any of the players. Then this card will surely be present in the envelope. Add it to the output.
If we could not find an all -1 row, then in that category, check each row for a 1 to be present. Note down the rows which doesn't have a 1. Those cards' players are still unknown. If we have only one such row (unknown card), then it must be in the envelope, as from each category one card is present in the envelope. Add it to the output.
For the card identified in Step 2, mark all the entries along that row in the knowledge matrix as -1, as this card doesn't belong to any player.

Looping Over

In our so far steps, we could note that, the knowledge matrix got updated even after "Result 0 processing" step. This updation in the knowledge matrix may help the "Result 0 processing" step, if we perform it again. So, we can loop over the steps, "Result 0 processing", "Cards per Player processing" and "Category-wise cards checking" again. This ensures that, we will get the desired number of envelop cards (three in our case) as output.

Hoping to see, many of you to finish Cody Contest 2025 and make our team win the trophy.

MathWorks Fixed Point Team
Last activity about 20 hours ago

Which "smart appliances" will make your wish-list this X'mas? We have an EXPO workshop for it!

Kishen Mahadevan
Last activity about 21 hours ago

AI-Based Reduced Order Modeling at MATLAB EXPO

Hi everyone!

I’m Kishen Mahadevan, Senior Product Manager at MathWorks, where I focus on controls and deep learning. I’m excited to be speaking at MATLAB EXPO this year!

In one of my sessions, I’ll share how AI-based reduced order models (ROMs) are transforming engineering workflows—using battery fast charging as an example—making it easier to reuse high-fidelity models for real-time control and deployment.

I’d love to have you join the conversation at the EXPO and right here in the community!

Feel free to drop any questions or thoughts ahead of the event.

Check out my sessions.

Dev Gupta
Last activity about 23 hours ago

Tips and Tricks for Problem 61069. Clueless - Lord Ned in the Game Room with the Technical Computing Language

Hi Everyone!

As this is the most difficult question in problem group "Cody Contest 2025". To solve this problem, It is very important to understand all the hidden clues in the problem statement. Because everything is not directly visible.

For those who tried the problem, but were not able to solve. You might have missed any of the below hints -

“The other players do not get to see which card has been shown, but they do know which three cards were asked for and that the player asked had one of them.” - Even when the card identity isn’t revealed (result = 0), you still gain partial knowledge — the asked player must have at least one of those three cards, meaning you can mark other players as not having all three simultaneously.
"If it is your turn, you know the exact identity of that card" - You only know the exact shown card when result = 1, 2, or 3 — and it must be your turn. If someone else asked (even if you know result = 0), you don’t know which one was shown. So the meaning of result depends on whose turn it was, which is implicit — MATLAB code must assume that turns alternate 1→m→1, so your turn index is determined by (t-1) mod m + 1 == pnum.
"Any leftover cards are placed face-up so that all players can see them" - These cards (commoncards) are not in anyone’s hand and cannot be in the envelope. So they’re not just visible — they’re logical constraints to eliminate from deduction.
“It may be possible to determine the solution from less information than is given, but the information given will always be sufficient.”
"Turn order is implied, not given explicitly" - Players take turns in order (1 to m, and back to 1).

On considering all the clues and constraints in the question, you will definitely be able to card for each category present in envelope.

I hope above clues will be useful for you.

Thank you, wishing you the success!

Regards,

Dev

General

PB75
Last activity on 13 Nov 2025 at 3:53

Tuning Cascade Control and Current Control PID Loops in a PMLSM model

Hi Everyone,

Require some guidance and pointers on model ee_pmlsm_drive please.

Its regarding a PMSM linear machine model, with a cascade (position and speed) outer loop and a current controller inner loop (Id and Iq currents).

The current Simulink model uses a low voltage DC supply (48v) and uses a step input to the system. My system uses a HV source (400v) and the input is sinusoidal position, with an operating frequency range of 0 to 20hz.

I have used the original model, re-created my own (to learn Simulink/Simscape) with a HV battery source (400v) and used machine parameters that match the application (peer reviewed publication).

As my power electronics background is limited, my background is mechanical, i am unable to tune the inner and outer loops, and am unsure in what order to tune. My project is to use the linear PMSM to drive (motoring) a linear piston for combustion and also use the linear piston to drive the PMSM (generating).

Using the built in PID tuner for the outer speed and position loops i am encountering an error (plant cannot be linearised). I am using a simple 1 hz sine wave to simulate the reference position set-point. With all PID values set to default i have no dq currents, however i have idq ref from the outer velocity controller loop.

Any help with resources and guidance as to how to tune the loops for my updated parameters on this model would be great.

Generative AI

Toshiaki Takeuchi
Last activity on 13 Nov 2025 at 3:35

Where do you fall in terms of the AI adoption curve for coding?

Cephas
Last activity on 13 Nov 2025 at 2:40

Preallocating Arrays Matters

Instead of growing arrays inside a loop, preallocate with zeros(), ones(), or nan(). It avoids memory fragmentation and speeds up Cody solutions.

A = zeros(1,1000);

Cephas
Last activity on 13 Nov 2025 at 2:38

Always Read the Example Output Carefully

Cody often hides subtle hints in example outputs — like data shape, rounding, or format. Matching those exactly saves you a lot of debugging time.

David Hill
Last activity on 13 Nov 2025 at 2:33

Using Persistent Variables to Survive Timeouts and Repeated Calls

When solving Cody problems, sometimes your solution takes too long — especially if you’re recomputing large arrays or iterative sequences every time your function is called.

The Cody work area resets between separate runs of your code, but within one Cody test suite, your function may be called multiple times in a single session.

This is where persistent variables come in handy.

A persistent variable keeps its value between function calls, but only while MATLAB is still running your function suite.

This means:

You can cache results to avoid recomputation.
You can accumulate data across multiple calls.
But it resets when Cody or MATLAB restarts.

Suppose you’re asked to find the n-th Fibonacci number efficiently — Cody may time out if you use recursion naively. Here’s how to use persistent to store computed values:

function f = fibPersistent(n)
import java.math.BigInteger
persistent F
if isempty(F)
   F=[BigInteger('0'),BigInteger('1')];
   for k=3:10000
       F(k)=F(k-1).add(F(k-2));
   end
end
    
% Extend the stored sequence only if needed
while length(F) <= n
    F(end+1)=F(end).add(F(end-1));
end
f = char(F(n+1).toString); % since F(1) is really F(0)
end
%calling function 100 times
K=arrayfun(@(x)fibPersistent(x),randi(10000,1,100),'UniformOutput',false);
K(100)
ans = 1×1 cell array
    {'563982230046568890902618956828002677439237127804414726979686441413745258166337260850508450357952871669760022932835205508650884432957132619548477681848951850249900098853578800502766453453321693488465782700659628264174757056271028413760264122292938046698234849427511943019674404460055307391183247077098238771593219759195361546550474847489454034087545485236581572021738623746876029952144698920606956981501906970107788143831844507572696523020854949377950584164671702209817937329138273107862450635272235829470591407489647002886722927663119075804284550987394985556133079386413055357606282374992498484308806888159999988894062720642359266610249180685549537651245402461171103020858571783996603386848039419656700597687469684534075920083663503623337165284634405944937809179503317603127766698557864519834438682815624108512662628659164318819211721788484510562704149517254432094419190323309859330458319203749328723347903942494042498481156385153413398528715754938381206379937482279105521608867050787631580424002980500346861332142946229358656510316436298104494540922341436539463379535760770882195633190667861276996489619134665056514210985714874297172396907228014612171439727292315001567764821061335577228917213918271255137714802428660758835259181668669987986012457471113553747414098971939000230951104638802770257722586728341096470806990469'}

David Hill
Last activity on 13 Nov 2025 at 1:39

Tackling Complex Nonlinear Equations with fzero

The fzero function can handle extremely messy equations — even those mixing exponentials, trigonometric, and logarithmic terms — provided the function is continuous near the root and you give a reasonable starting point or interval.

It’s ideal for cases like:

Solving energy balance equations
Finding intersection points of nonlinear models
Determining parameters from experimental data

Example: Solving for Equilibrium Temperature in a Heat Radiation-Conduction Model

Suppose a spacecraft component exchanges heat via conduction and radiation with its environment. At steady state, the power generated internally equals the heat lost:

Given constants:

= 25 W
k = 0.5 W/K
ϵ = 0.8
σ = 5.67e−8 W/m²K⁴
A = 0.1 m²
= 250 K

Find the steady-state temperature, T.

% Given constants

Qgen = 25;

k = 0.5;

eps = 0.8;

sigma = 5.67e-8;

A = 0.1;

Tinf = 250;

% Define the energy balance equation (set equal to zero)

f = @(T) Qgen - (k*(T - Tinf) + eps*sigma*A*(T.^4 - Tinf^4));

% Plot for a sense of where the root lies before implementing

fplot(f, [250 300]); grid on

xlabel('Temperature (K)'); ylabel('f(T)')

title('Energy Balance: Root corresponds to steady-state temperature')

% Use fzero with an interval that brackets the root

T_eq = fzero(f, [250 300]);

fprintf('Steady-state temperature: %.2f K\n', T_eq);

Steady-state temperature: 279.82 K

Fun

Ludvig Nordin
Last activity on 13 Nov 2025 at 1:24

Which is your favorite?

Naomi Fernandes
Last activity on 12 Nov 2025 at 21:03

🚀 MATLAB EXPO 2025 – Day 2 Starts Tomorrow, November 13!

Don’t miss out on two incredible keynotes that will shape the future of engineering and innovation:

1️⃣What’s New in MATLAB and Simulink in 2025

Get an inside look at the latest features designed to supercharge your workflows:

A redesigned MATLAB desktop with customizable sidebars, light/dark themes, and new panels for coding tasks
MATLAB Copilot – your AI-powered assistant for learning, idea generation, and productivity
Simulink upgrades, including an enhanced quick insert tool, auto-straightening signal lines, and new methods for Python integration
New options to deploy AI models on Qualcomm and Infineon hardware

2️⃣Accelerating Software-Defined Vehicles with Model-Based Design

See how MathWorks + NXP are transforming embedded system development for next-gen vehicles:

Vehicle electrification example powered by MATLAB, Simulink, and NXP tools
End-to-end workflow: modeling → validation → code generation → hardware deployment → real-time cloud monitoring

📅 When: November 13

💡Why Join? Stay ahead with cutting-edge tools, workflows, and insights from industry leaders.

👉 Register now and be part of the future of engineering!

Chen Lin
Last activity on 12 Nov 2025 at 20:16

Introduce Yourself to Team Relentless Coders! 👋

Hey Relentless Coders! 😎

You can share:

Your name or nickname
Where you’re from
Your favorite coding topic or language
What you’re most excited about in the contest

Let’s make Team Relentless Coders an awesome community—jump in and say hi! 🚀

idris
Last activity on 12 Nov 2025 at 15:29

Awards vs Background

In the FAQs, I saw the procedure to download the "mobile background", is the the same thing as an award? If yes, good, else how can we get an award and what are the available ones?

iaabdulhameed@knu.ac.kr

Cephas
Last activity on 12 Nov 2025 at 14:13

Vectorization Over Loops

I realized that using vectorized logic instead of nested loops makes Cody problems run much faster and cleaner. Functions like any(), all(), and logical indexing can replace multiple for-loops easily !