From a3c316dbfeefd4b588ef35cf089fa5b57884ec51 Mon Sep 17 00:00:00 2001
From: HiradTorabi <babak.torabi.1384@gmail.com>
Date: Sat, 8 Mar 2025 17:23:33 +0330
Subject: [PATCH 1/2] salam

testing
---
 .../src/main/java/Exercises.java              | 96 +++++++++++++++++--
 1 file changed, 87 insertions(+), 9 deletions(-)

diff --git a/AP1403 - Algorithms/src/main/java/Exercises.java b/AP1403 - Algorithms/src/main/java/Exercises.java
index 15a2133..18fb943 100644
--- a/AP1403 - Algorithms/src/main/java/Exercises.java	
+++ b/AP1403 - Algorithms/src/main/java/Exercises.java	
@@ -8,8 +8,20 @@ public class Exercises {
 
         note: you should return the indices in ascending order and every array's solution is unique
     */
-    public int[] productIndices(int[] values, int target) {
-        // todo
+    public int[] productIndices(int[] values, int target)
+    {
+        int n = values.length;
+        for (int i = 0; i < n; ++i)
+        {
+            for (int j = i + 1; j < n; ++j)
+            {
+             if (values[i] * values[j] == target)
+             {
+                 return new int[] {i, j};
+             }
+            }
+
+        }
         return null;
     }
 
@@ -24,11 +36,49 @@ public int[] productIndices(int[] values, int target) {
 
         so you should walk in that matrix in a curl and then add the numbers in order you've seen them in a 1D array
     */
-    public int[] spiralTraversal(int[][] values, int rows, int cols) {
-        // todo
-        return null;
+    public int[] spiralTraversal(int[][] values, int rows, int cols)
+    {
+        if (values == null || rows == 0 || cols == 0)
+        {
+            return new int[0];
+        }
+        int[] result = new int[rows * cols];
+        int index = 0;
+        int top = 0, bottom = rows - 1;
+        int left = 0, right = cols - 1;
+        while (top <= bottom && left <= right)
+        {
+            for (int i = left; i <= right; i++)
+            {
+                result[index++] = values[top][i];
+            }
+            top++;
+            for (int i = top; i <= bottom; i++)
+            {
+                result[index++] = values[i][right];
+            }
+            right--;
+            if (top <= bottom)
+            {
+                for (int i = right; i >= left; i--)
+                {
+                    result[index++] = values[bottom][i];
+                }
+                bottom--;
+            }
+            if (left <= right)
+            {
+                for (int i = bottom; i >= top; i--)
+                {
+                    result[index++] = values[i][left];
+                }
+                left++;
+            }
+        }
+        return result;
     }
 
+
     /*
         integer partitioning is a combinatorics problem in discreet maths
         the problem is to generate sum numbers which their summation is the input number
@@ -53,12 +103,40 @@ public int[] spiralTraversal(int[][] values, int rows, int cols) {
 
         if you're familiar with lists and arraylists, you can also edit method's body to use them instead of array
     */
-    public int[][] intPartitions(int n) {
-        // todo
-        return null;
+    public class IntegerPartition
+    {
+        public static void main(String[] args)
+        {
+            int n = 4;
+            int[] partition = new int[n];
+            partition(n, n, partition, 0);
+        }
+        public static void partition(int n, int max, int[] partition, int index)
+        {
+            if (n == 0)
+            {
+                printPartition(partition,index);
+                return;
+            }
+
+            for (int i = Math.min(max,n); i >= 1; i--)
+            {
+                partition[index] = i;
+                partition(n - i, i, partition, index + 1);
+            }
+        }
+        public static void printPartition(int[] partition, int length)
+        {
+            for (int i = 0; length > i; i++)
+            {
+                System.out.print(partition[i] + " ");
+            }
+            System.out.println();
+        }
     }
 
-    public static void main(String[] args) {
+    public static void main(String[] args)
+    {
         // you can test your code here
     }
 }

From 952c68af32458307566d902ee84477654626a62d Mon Sep 17 00:00:00 2001
From: HiradTorabi <babak.torabi.1384@gmail.com>
Date: Fri, 14 Mar 2025 19:14:40 +0330
Subject: [PATCH 2/2] Add files via upload

---
 .../AP1403 - Algorithms/pom.xml               |  38 +++++
 .../src/main/java/Exercises.java              | 160 ++++++++++++++++++
 .../src/test/java/TestPartitions.java         |  65 +++++++
 .../src/test/java/TestProduct.java            |  37 ++++
 .../src/test/java/TestTraversal.java          |  66 ++++++++
 .../classes/Exercises$IntegerPartition.class  | Bin 0 -> 1668 bytes
 .../target/classes/Exercises.class            | Bin 0 -> 1449 bytes
 First-Assignment-Algorithms/README.md         |  42 +++++
 8 files changed, 408 insertions(+)
 create mode 100644 First-Assignment-Algorithms/AP1403 - Algorithms/pom.xml
 create mode 100644 First-Assignment-Algorithms/AP1403 - Algorithms/src/main/java/Exercises.java
 create mode 100644 First-Assignment-Algorithms/AP1403 - Algorithms/src/test/java/TestPartitions.java
 create mode 100644 First-Assignment-Algorithms/AP1403 - Algorithms/src/test/java/TestProduct.java
 create mode 100644 First-Assignment-Algorithms/AP1403 - Algorithms/src/test/java/TestTraversal.java
 create mode 100644 First-Assignment-Algorithms/AP1403 - Algorithms/target/classes/Exercises$IntegerPartition.class
 create mode 100644 First-Assignment-Algorithms/AP1403 - Algorithms/target/classes/Exercises.class
 create mode 100644 First-Assignment-Algorithms/README.md

diff --git a/First-Assignment-Algorithms/AP1403 - Algorithms/pom.xml b/First-Assignment-Algorithms/AP1403 - Algorithms/pom.xml
new file mode 100644
index 0000000..f46c801
--- /dev/null
+++ b/First-Assignment-Algorithms/AP1403 - Algorithms/pom.xml	
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>org.project</groupId>
+    <artifactId>Algorithms</artifactId>
+    <version>1.0-SNAPSHOT</version>
+
+    <properties>
+        <maven.compiler.source>21</maven.compiler.source>
+        <maven.compiler.target>21</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter</artifactId>
+            <version>5.11.4</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <pluginManagement>
+            <plugins>
+                <plugin>
+                    <groupId>org.apache.maven.plugins</groupId>
+                    <artifactId>maven-surefire-plugin</artifactId>
+                    <version>3.5.2</version>
+                </plugin>
+            </plugins>
+        </pluginManagement>
+    </build>
+
+</project>
\ No newline at end of file
diff --git a/First-Assignment-Algorithms/AP1403 - Algorithms/src/main/java/Exercises.java b/First-Assignment-Algorithms/AP1403 - Algorithms/src/main/java/Exercises.java
new file mode 100644
index 0000000..d4788a9
--- /dev/null
+++ b/First-Assignment-Algorithms/AP1403 - Algorithms/src/main/java/Exercises.java	
@@ -0,0 +1,160 @@
+import java.util.Arrays;
+
+public class Exercises {
+
+    /*
+        there is an array of positive integers as input of function and another integer for the target value
+        all the algorithm should do is to find those two integers in array which their multiplication is the target
+        then it should return an array of their indices
+        e.g. {1, 2, 3, 4} with target of 8 -> {1, 3}
+
+        note: you should return the indices in ascending order and every array's solution is unique
+    */
+    public int[] productIndices(int[] values, int target)
+    {
+        int n = values.length;
+        for (int i = 0; i < n; ++i)
+        {
+            for (int j = i + 1; j < n; ++j)
+            {
+                if (values[i] * values[j] == target)
+                {
+                    return new int[] {i, j};
+                }
+            }
+
+        }
+        return null;
+
+       /* public static void main(String[] args)
+        {
+        int[] values = {2, 5, 1, 4, 10, 69, 420};
+        int target = 420;
+        int[] result = productIndices(values, target);
+
+        if (result.length > 0)
+        {
+            System.out.println("Indices: " + Arrays.toString(result));
+        }
+        else
+        {
+            System.out.println("No pair found.");
+        }
+    }*/
+    }
+
+    /*
+        given a matrix of random integers, you should do spiral traversal in it
+        e.g. if the matrix is as shown below:
+        1 2 3
+        4 5 6
+        7 8 9
+        then the spiral traversal of that is:
+        {1, 2, 3, 6, 9, 8, 7, 4, 5}
+
+        so you should walk in that matrix in a curl and then add the numbers in order you've seen them in a 1D array
+    */
+    public int[] spiralTraversal(int[][] values, int rows, int cols)
+    {
+        if (values == null || rows == 0 || cols == 0)
+        {
+            return new int[0];
+        }
+        int[] result = new int[rows * cols];
+        int index = 0;
+        int top = 0, bottom = rows - 1;
+        int left = 0, right = cols - 1;
+        while (top <= bottom && left <= right)
+        {
+            for (int i = left; i <= right; i++)
+            {
+                result[index++] = values[top][i];
+            }
+            top++;
+            for (int i = top; i <= bottom; i++)
+            {
+                result[index++] = values[i][right];
+            }
+            right--;
+            if (top <= bottom)
+            {
+                for (int i = right; i >= left; i--)
+                {
+                    result[index++] = values[bottom][i];
+                }
+                bottom--;
+            }
+            if (left <= right)
+            {
+                for (int i = bottom; i >= top; i--)
+                {
+                    result[index++] = values[i][left];
+                }
+                left++;
+            }
+        }
+        return result;
+    }
+
+
+    /*
+        integer partitioning is a combinatorics problem in discreet maths
+        the problem is to generate sum numbers which their summation is the input number
+
+        e.g. 1 -> all partitions of integer 3 are:
+        3
+        2, 1
+        1, 1, 1
+
+        e.g. 2 -> for number 4 goes as:
+        4
+        3, 1
+        2, 2
+        2, 1, 1
+        1, 1, 1, 1
+
+        note: as you can see in examples, we want to generate distinct summations, which means 1, 2 and 2, 1 are no different
+        you should generate all partitions of the input number and
+
+        hint: you can measure the size and order of arrays by finding the pattern of partitions and their number
+        trust me, that one's fun and easy :)
+
+        if you're familiar with lists and arraylists, you can also edit method's body to use them instead of array
+    */
+    public class IntegerPartition
+    {
+        public static void main(String[] args)
+        {
+            int n = 4;
+            System.out.println("Integer partitions of " + n + " is:");
+            int[] partition = new int[n];
+            partition(n, n, partition, 0);
+        }
+        public static void partition(int n, int max, int[] partition, int index)
+        {
+            if (n == 0)
+            {
+                printPartition(partition,index);
+                return;
+            }
+            for (int i = Math.min(max,n); i >= 1; i--)
+            {
+                partition[index] = i;
+                partition(n - i, i, partition, index + 1);
+            }
+        }
+        public static void printPartition(int[] partition, int length)
+        {
+            for (int i = 0; length > i; i++)
+            {
+                System.out.print(partition[i] + " ");
+            }
+            System.out.println();
+        }
+    }
+
+    public static void main(String[] args)
+    {
+        // you can test your code here
+    }
+}
diff --git a/First-Assignment-Algorithms/AP1403 - Algorithms/src/test/java/TestPartitions.java b/First-Assignment-Algorithms/AP1403 - Algorithms/src/test/java/TestPartitions.java
new file mode 100644
index 0000000..c9e62db
--- /dev/null
+++ b/First-Assignment-Algorithms/AP1403 - Algorithms/src/test/java/TestPartitions.java	
@@ -0,0 +1,65 @@
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+
+public class TestPartitions {
+    static Exercises ex;
+
+    @BeforeAll
+    static void setUp() {
+        ex = new Exercises();
+    }
+
+    @Test
+    void testPartition0() {
+        int[][] expected = {
+                {1}
+        };
+        assertArrayEquals(expected, ex.intPartitions(1));
+    }
+
+    @Test
+    void testPartition1() {
+        int[][] expected = {
+                {4},
+                {3, 1},
+                {2, 2},
+                {2, 1, 1},
+                {1, 1, 1, 1}
+        };
+        assertArrayEquals(expected, ex.intPartitions(4));
+    }
+
+    @Test
+    void testPartition2() {
+        int[][] expected = {
+                {5},
+                {4, 1},
+                {3, 2},
+                {3, 1, 1},
+                {2, 2, 1},
+                {2, 1, 1, 1},
+                {1, 1, 1, 1, 1}
+        };
+        assertArrayEquals(expected, ex.intPartitions(5));
+    }
+
+    @Test
+    void testPartition3() {
+        int[][] expected = {
+                {6},
+                {5, 1},
+                {4, 2},
+                {4, 1, 1},
+                {3, 3},
+                {3, 2, 1},
+                {3, 1, 1, 1},
+                {2, 2, 2},
+                {2, 2, 1, 1},
+                {2, 1, 1, 1, 1},
+                {1, 1, 1, 1, 1, 1}
+        };
+        assertArrayEquals(expected, ex.intPartitions(6));
+    }
+}
diff --git a/First-Assignment-Algorithms/AP1403 - Algorithms/src/test/java/TestProduct.java b/First-Assignment-Algorithms/AP1403 - Algorithms/src/test/java/TestProduct.java
new file mode 100644
index 0000000..2bae3e7
--- /dev/null
+++ b/First-Assignment-Algorithms/AP1403 - Algorithms/src/test/java/TestProduct.java	
@@ -0,0 +1,37 @@
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+
+public class TestProduct {
+    static Exercises ex;
+
+    @BeforeAll
+    static void setUp() {
+        ex = new Exercises();
+    }
+
+    @Test
+    void testProduct0() {
+        int[] nums = {5, 10, 2, 20};
+        int target = 20;
+        int[] expected = {1, 2};
+        assertArrayEquals(expected, ex.productIndices(nums, target));
+    }
+
+    @Test
+    void testProduct1() {
+        int[] nums = {3, 7, 1, 14};
+        int target = 21;
+        int[] expected = {0, 1};
+        assertArrayEquals(expected, ex.productIndices(nums, target));
+    }
+
+    @Test
+    void testProduct2() {
+        int[] nums = {69, 15, 17, 23, 5, 11, 4, 6, 85, 39, 81, 34, 76, 21, 3, 36, 98, 77, 9, 42};
+        int target = 2898;
+        int[] expected = {0, 19};
+        assertArrayEquals(expected, ex.productIndices(nums, target));
+    }
+}
diff --git a/First-Assignment-Algorithms/AP1403 - Algorithms/src/test/java/TestTraversal.java b/First-Assignment-Algorithms/AP1403 - Algorithms/src/test/java/TestTraversal.java
new file mode 100644
index 0000000..969c273
--- /dev/null
+++ b/First-Assignment-Algorithms/AP1403 - Algorithms/src/test/java/TestTraversal.java	
@@ -0,0 +1,66 @@
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+
+public class TestTraversal {
+    static Exercises ex;
+
+    @BeforeAll
+    static void setUp() {
+        ex = new Exercises();
+    }
+
+    @Test
+    void testTraverse0() {
+        int[][] nums = {
+                {1, 2, 3, 4, 5}
+        };
+        int rows = 1;
+        int cols = 5;
+        int[] expected = {1, 2, 3, 4, 5};
+        assertArrayEquals(expected, ex.spiralTraversal(nums, rows, cols));
+    }
+
+    @Test
+    void testTraverse1() {
+        int[][] nums = {
+                {1, 2, 3},
+                {4, 5, 6},
+                {7, 8, 9},
+                {10, 11, 12}
+        };
+        int rows = 4;
+        int cols = 3;
+        int[] expected = {1, 2, 3, 6, 9, 12, 11, 10, 7, 4, 5, 8};
+        assertArrayEquals(expected, ex.spiralTraversal(nums, rows, cols));
+    }
+
+    @Test
+    void testTraverse2() {
+        int[][] nums = {
+                {1, 2, 3, 4},
+                {5, 6, 7, 8}
+        };
+        int rows = 2;
+        int cols = 4;
+        int[] expected = {1, 2, 3, 4, 8, 7, 6, 5};
+        assertArrayEquals(expected, ex.spiralTraversal(nums, rows, cols));
+    }
+
+    @Test
+    void testTraverse3() {
+        int[][] nums = {
+                {1, 2, 3, 4, 5, 6},
+                {7, 8, 9, 10, 11, 12},
+                {13, 14, 15, 16, 17, 18},
+                {19, 20, 21, 22, 23, 24},
+                {25, 26, 27, 28, 29, 30}
+        };
+        int rows = 5;
+        int cols = 6;
+        int[] expected = {1, 2, 3, 4, 5, 6, 12, 18, 24, 30, 29, 28, 27, 26, 25, 19, 13, 7, 8, 9, 10, 11, 17, 23, 22, 21,
+                20, 14, 15, 16};
+        assertArrayEquals(expected, ex.spiralTraversal(nums, rows, cols));
+    }
+}
diff --git a/First-Assignment-Algorithms/AP1403 - Algorithms/target/classes/Exercises$IntegerPartition.class b/First-Assignment-Algorithms/AP1403 - Algorithms/target/classes/Exercises$IntegerPartition.class
new file mode 100644
index 0000000000000000000000000000000000000000..8624799f414fa31fa07727b8370dfc5275b9f431
GIT binary patch
literal 1668
zcmaJ?TW=dh6#mBEcx`8MX@V0HJ0T4zIKd<VO1U^K(9jTra{)&IDKAW%QL>G_Ypo|$
zBO!6C5J(jWsj3QZNJxD{Di0;95I=zb!3#g3stDigT5(Du9=vnrT)y+2b7sbW{`24u
z0B>O}jTquKEC(G(2=rc+*W^r1dfPKAn^#p;3nb=T&()U%;`zz-G?GZ!NIU3+BQSjB
zx(cdpQ#B__o>to`Se1cxwd;EVsYY8)=1ZlGQYixHcF==ff$m1&diq#IBH!}qL%)qD
z9Aq#+w>GCGsdq@E?h?L(kdvhpp2U!iVFy{{9^+rxZ)#Pix4*|KGUX7(^=DR1(uxk0
ztQY&(gi!}iVN77KE_c<u?^UJ#(A7JXnp%3g$=G~pG71kH!&ukbE~YV#r)^9)IEQBh
z`cJ_p$*@ENaT35ZV;p%0lcw`_=viZ7-TCrSTZ@zH0@l30r38A)uBVpw>YFN9lbbba
z`pSM)*4Aa<nte-Y=^dA(b8V0lvng__#%p3$ptJ2qb?=hWJN_1DBI`=4fIwDVnsyK5
zH%=>ob{TBbt^X9WfMBF33B)$|5w4k?yw0|`-j?FpRnfA#yCfSe?unZ6w#|ss6@M?N
zss-1S*?rWGY13qZ<g#k&MZc+S%=4TbnaTgM@9U-xWFso1nZyFKi?N;r7Skx<T^sM2
zftLj)+ULskuKBxaCYo$?1{P#h`@z1zo#UfxIY!`%(%Y)>=$Czecdt=A*`8yX#{$>(
z8|oDI;~k7{U-9_4YeCG*TCL)0#c4Su&r`vCO*VN0S^R(Rpp8|5b0^9?jlGQz1V;bg
zm8T{u6=(Sj#CUfA3!EmVxO<Mf*SItKj;Y@u?oo)Lz;A+T;1fL0??B{$Y0Pj(SIpuC
z+Fvv>-9GC@3NPV2RR-}RW{7j`w&$|Hr<bzXLi_-B8@i8n1`+ggruhP0_%cj07DeG@
zT%bJ$2e05&VkXGElRRV0!Y8bi<rmWEpx^B9k4P0p4$yTkJA8mM7p#nB{e)~`Bx9`%
zXRNJ^RT!~8CW9N+;oZZ(43BtN;y7`EugK<WB7cK4ZekGMB8TsIzi+bG??Ybandb~f
z@jBTU=CdI$3Y3Z=LnB2DjWkDH92aR%Bc6W5m*OEtn1K&yi~Favn+}b~FJ^N;WAIlD
zPUWT_&<po*_C`$HJ^Y)x`*^m^b|9?w7Hr(+8+(gy=N-=UhojELFcdO0vm6iEP@r@v
zWN6r=5PQUX^^ni6g*T{(;Z6RZnDsK==9(nEclf)4CGPsDPtvkX%?jQ}1w;P=D}!|=

literal 0
HcmV?d00001

diff --git a/First-Assignment-Algorithms/AP1403 - Algorithms/target/classes/Exercises.class b/First-Assignment-Algorithms/AP1403 - Algorithms/target/classes/Exercises.class
new file mode 100644
index 0000000000000000000000000000000000000000..0e02a5c03b968c121f95ce8ad5b4efea146040f4
GIT binary patch
literal 1449
zcmZuw&u<$=6#mBh%ibhSoOaqIwV{->bz*Q(kt{+=AVdWjxiOFu8d->L?5(rG*^Sog
zPzkB0aNvTt!li`@l~W0-1X772aY3RN!~rP>?)(o`z<jfgoCsLi^WMDo%{TAYJo@|L
zE`T{aXCnd4g5D1Urohmev*}DV9ltSESy^*yk$`#0^Sx+RK+8=mSx5?`F5h&+n%8n$
z0{VPVcLfH^p6@QS*H_%|s<YChWw;#FoaT}fdTM`Q)T338hx*Drh8cll8(~my*P@bN
z_iBpM%2i9HiE2qetnsg;$2c~fW?Q)v%40@O*l-!1@C61IBd7Mk6=&n%n!(nF7dp+W
zp|k0REvLzlb5(M7Nj0hrJPbZm@z;VTg&Df7c9V35=hxkvOg0KOXkH1TC|D<~>E2M@
z&}*zl7RD@`pmE*tc>Bp*wR~8%#VGXr#>~VL{S1-Z$N$GIU@r#ku;#wzsbU@L)uW)8
zSfK^C6<u*vJzEx@6&ULw#!G(WHr(({Cyczv3m8Fv$@krGzUj2$o(%mPfu~@x&+5~`
zEMRg?aW_RND2>S<AikrLfX!980S$dz`?~<j0qz(o2Dz%kzmd$OoXhXdYDHb@*{@KP
zx_-TANQ3%#Uh0LsGzzPkJ4hQl_Od4R%Catv%J!Ba?sfjy(z!ko+a%HAi_aoSeUQ5$
zUO0>qoWMDp#PigrX?q!`<Dh1F@h~pXl8&>P<}S@})JS&&RoZc$R*B3((#tu=EV<H@
zr)V99@fSy4?4wVdc?^R;qDL^=O)qhQe5wF@`Jd63`5adE3s~BYy`9Of?$|HtTG7yo
zW=5|UEv=Z$Ql_LSt-H7<lQMM|cVx0?OIxWUqfDA9=cRd3+J(xN&Ak8IGKDl_2oD`X
z?29thgQPlL&hs)ABa>eqL0Si79Ytn!;%hs%q!lC0qeyZl6=#f0^73n=`eD`AFvdJ*
zSh<(t8lS=|w9MfwUd1Hl@d7S$eI0L8UPB30yn!1iqfPk{7H|s{e2lm785VJy@@u?<
zZ}2X@#WEfe{R`!<cn`nhdR);@IYgI`iF;<_{hszoPkYeQSpQx}_t?>~xTAZV1JzOG
z%^Y;}CuG@gorqmLL7Tz-k9d-r$xOb-8EO`%=>cCunsYXZ`?RMy%4!;>G0?Ad*nHc9
zW#MTdEQ|~F0sBac$2h&uX^F*v5{Z4-N*W|Mhx6T`L7r4<<o@%RZXbC}f|HvgNW%oz
U1S3($)XRJZ1!{JzS?YEE16dpfs{jB1

literal 0
HcmV?d00001

diff --git a/First-Assignment-Algorithms/README.md b/First-Assignment-Algorithms/README.md
new file mode 100644
index 0000000..bec7e9d
--- /dev/null
+++ b/First-Assignment-Algorithms/README.md
@@ -0,0 +1,42 @@
+# First Assignment - Algorithms
+
+Are you ready to challenge yourself with some algorithmic problems?  
+This section will help strengthen your *Java* skills and reinforce the **Way of BP**.
+
+
+## Getting Started
+
+This is the second part of your first assignment in the *Advanced Programming* course.  
+We strongly recommend that you complete the first part – [Warm-Up](https://github.com/Advanced-Programming-1403/First-Assignment-WarmUp) – before starting.
+
+Just like in the previous section, you will need to solve three problems using the same approach.
+
+
+## Evaluation
+
+To successfully complete this assignment, you must:
+
+- Implement the functions as described in the comments, ensuring your code compiles and runs without errors.  
+- Pass all unit tests in the `src/test/java` directory.  
+- Write **clean and readable code** for your mentor. It is recommended to:  
+    - Use meaningful comments.  
+    - Follow **clean-code principles** for better readability and maintainability.  
+
+
+## Submission Instructions
+
+To submit your assignment for review, follow the same steps mentioned in the *Warm-Up* section, using Git for version control.
+
+**Tip:** It's recommended to use *branches* in Git:  
+- Commit your changes in `origin/develop`.  
+- Create a pull request for your mentor to review.
+
+
+## Important Notes
+
+**Strictly prohibited:** Using ChatGPT or any other generative AI tool to solve any part of this assignment.  
+**Allowed:** Using AI tools to clarify concepts and learning, but not for direct answers.  
+**Best Practice:** If you're struggling, try searching, asking questions, or consulting official documentation.
+
+<br />
+Good luck, and happy coding!