add exercise solutions

Author: jeffsieu

chapters/1-basics/1-type-annotations/exercise-1.1.solution.ts

@@ -0,0 +1,25 @@
+// Exercise 1.1: Type annotations
+// Add/correct type annotations to all the variable and functions below.
+
+const age: number = 25;
+const message: string = "Hello, world!";
+const isTrue: boolean = true;
+
+function add(a: number, b: number): number {
+  return a + b;
+}
+
+function sayHello(name: string): string {
+  return `Hello, ${name}!`;
+}
+
+function isEven(n: number): boolean {
+  return n % 2 === 0;
+}
+
+function getAge(): number {
+  return 25;
+}
+
+// ignore the line below
+export {};

chapters/1-basics/10-arrays-records-tuples/exercise-10.1.solution.ts

@@ -0,0 +1,28 @@
+// Exercise 10.1: Arrays, Records and Tuples
+
+// 1. Create a type annotation for an array of numbers
+const scores: number[] = [75, 82, 90, 88, 95];
+
+// 2. Create a type annotation for a tuple of [string, number, boolean]
+const userInfo: [string, number, boolean] = ["Alice", 28, true];
+
+// 3. Create a type annotation for a record with string keys and number values
+const studentGrades: Record<string, number> = {
+  Alice: 95,
+  Bob: 87,
+  Charlie: 92,
+};
+
+// 4. Create a function that takes an array of numbers and returns their sum
+function sumScores(scores: readonly number[]) {
+  return scores.reduce((sum, score) => sum + score, 0);
+}
+
+// 5. Create a function that takes a tuple of [string, number] and returns a greeting
+function greetWithAge(info: [string, number]) {
+  const [name, age] = info;
+  return `Hello, ${name}! You are ${age} years old.`;
+}
+
+// ignore the line below
+export {};

chapters/1-basics/12-readonly-types-as-const/exercise-12.1.solution.ts

@@ -0,0 +1,46 @@
+// Exercise 12.1: Readonly types and "as const"
+
+// 1. Create a readonly version of the following interface
+type User = {
+  id: number;
+  name: string;
+  email: string;
+}
+
+type ReadonlyUser = Readonly<User>;// Your implementation here
+
+// 2. Use the readonly version to annotate the following object
+const alice: ReadonlyUser = {
+  id: 1,
+  name: "Alice",
+  email: "alice@example.com"
+};
+
+// 3. Create a readonly array of numbers
+const luckyNumbers: readonly number[] = [7, 13, 42, 99];
+
+// 4. Use "as const" to create a readonly tuple of string literals
+const directions = ["North", "South", "East", "West"] as const;
+
+// 5. Create a function that takes a readonly array of numbers and tries to modify it
+function doubleNumbers(numbers: readonly number[]) {
+  // Try to modify the array (this should cause a type error)
+  // numbers[0] = numbers[0] * 2;
+  return numbers.map(n => n * 2);
+}
+
+// 6. Modify the following object to make it a readonly object using "as const"
+const config = {
+  api: {
+    url: "https://api.example.com",
+    version: "v1",
+  },
+  timeout: 5000,
+  retries: 3,
+} as const;
+
+// 7. Try to modify a property of the config object (this should cause a type error)
+// config.api.url = "https://new-api.example.com";
+
+// ignore the line below
+export {};

chapters/1-basics/2-inferred-types/exercise-2.1.solution.ts

@@ -0,0 +1,22 @@
+// Exercise 2.1: Inferred types
+// Identify and remove unnecessary type annotations
+
+// Note: Typescript should not be complaining (no red squiggles) after
+// your changes
+
+function add(a: number, b: number) {
+  return a + b;
+}
+
+function canBuy(itemPrice: number, balance: number) {
+  const hasEnoughMoney = balance >= itemPrice;
+  return hasEnoughMoney;
+}
+
+function getFullName(firstName: string, lastName: string) {
+  const fullName = `${firstName} ${lastName}`;
+  return fullName;
+}
+
+// ignore the line below
+export {};

chapters/1-basics/3-overriding-inferred-types/exercise-3.1.solution.ts

@@ -0,0 +1,11 @@
+// Exercise 3.1: Overriding inferred types
+// Add explicit type annotations to fix the TypeScript errors
+
+let a: number | null = 10; // Change this line
+a = null;
+
+let b: null | string = "my string"; // Change this line
+b = null;
+
+// ignore the line below
+export {};

chapters/1-basics/5-object-types-and-interfaces/exercise-5.1.solution.ts

@@ -0,0 +1,22 @@
+// Exercise 5.1: Object types and interfaces
+
+// Create an interface/type Animal with properties name (string) and sound (string).
+type Animal = {
+  name: string;
+  sound: string;
+}
+
+// Create an interface/type Dog that extends Animal and adds a property breed (string).
+type Dog = Animal & {
+  breed: string;
+}
+
+// Create a variable myDog of type Dog and assign it an object with appropriate values.
+const myDog: Dog = {
+  name: 'dog',
+  sound: 'bark',
+  breed: 'chihuahua'
+}
+
+// ignore the line below
+export {}

chapters/1-basics/6-optional-properties-and-parameters/exercise-6.1.solution.ts

@@ -0,0 +1,122 @@
+// EXERCISE 6.1: Optional properties and parameters
+// Add type annotations where necessary and modify the functions to handle optional parameters appropriately.
+
+// 1. Refactor this function to use an optional parameter for 'title'
+function greet(name: string, title?: string) {
+  if (title) {
+    return `Hello, ${title} ${name}!`;
+  }
+  return `Hello, ${name}!`;
+}
+
+// TESTS
+// Should work:
+console.log(greet("Alice", "Ms."));
+console.log(greet("Bob"));
+
+// Should not work:
+// console.log(greet("Charlie", "Mr.", "Brown"));
+
+
+// 2. Define a type for User
+//    - name
+//    - age (optional)
+//    - email (optional)
+//    - isAdmin
+//    - address (optional)
+type User = {
+  name: string;
+  age?: number | string;
+  email?: string;
+  isAdmin: boolean
+  address?: Address;
+};
+
+// 3. Define type for Address
+//    - street
+//    - city
+//    - country
+type Address = {
+  street: string;
+  city: string;
+  country: string;
+};
+
+// 4. Create a type for the configuration object with optional properties
+type UserConfig = {
+  name: string;
+  age?: number;
+  email?: string;
+  isAdmin?: boolean;
+}; // Your implementation here
+
+// 5. Refactor the function to take in UserConfig and return User.
+function createUser(config: UserConfig): User {
+  return {
+    name: config.name,
+    age: config.age ?? "Unknown",
+    email: config.email ?? "No email provided",
+    isAdmin: config.isAdmin ?? false,
+  };
+}
+
+// TESTS
+// Should work:
+const user1 = createUser({
+  name: "Charlie",
+  age: 30,
+  email: "charlie@example.com",
+});
+const user2 = createUser({ name: "David", isAdmin: true });
+
+// 6. Add appriopriate type annotations
+// Then, refactor this function to use optional chaining and nullish coalescing
+function getFullAddress(user: User) {
+  const street = user.address?.street
+      ?? "Unknown street";
+  const city = user.address?.city ?? "Unknown city";
+  const country =  user.address?.country ?? "Unknown country";
+
+  return `${street}, ${city}, ${country}`;
+}
+
+// 7. Create a type for the product with optional properties
+//   - name
+//   - price
+//   - description (optional)
+//   - category (optional)
+type Product = {
+  name: string;
+  price: number;
+  description?: string;
+  category?: string;
+}; // Your implementation here
+
+// Then, refactor the function to use this type and handle optional properties
+function displayProductInfo(product: Product) {
+  let info = `${product.name} - $${product.price}`;
+
+  if (product.description) {
+    info += `\nDescription: ${product.description}`;
+  }
+
+  if (product.category) {
+    info += `\nCategory: ${product.category}`;
+  }
+
+  return info;
+}
+
+// TESTS
+// Should work:
+const product1 = {
+  name: "Laptop",
+  price: 999.99,
+  description: "Powerful laptop for professionals",
+};
+const product2 = { name: "Mouse", price: 19.99 };
+console.log(displayProductInfo(product1));
+console.log(displayProductInfo(product2));
+
+// ignore the line below
+export {}

chapters/1-basics/7-union-and-literal-types/exercise-7.1.solution.ts

@@ -0,0 +1,93 @@
+// EXERCISE 7.1: Union and literal types
+// Use union types and literal types to improve the following code.
+// Add type annotations where necessary.
+
+// 1. Create a union type for different shapes
+// Hint: Use "circle", "square", and "triangle" as literal types
+type Shape = "circle" | "square" | "triangle";
+
+// 2. Create a type for a point in 2D space
+// The x and y coordinates should only allow -1, 0, or 1
+type Point = {
+  x: -1 | 0 | 1;
+  y: -1 | 0 | 1;
+};
+
+// 3. Create a union type for different HTTP methods
+// Hint: Use "GET", "POST", "PUT", "DELETE" as literal types
+type HttpMethod = "GET" | "POST" | "PUT" | "DELETE";
+
+// 4. Create a type for API response status
+// It should allow "success" and "error" as string literals, or a number for the status code
+type ApiStatus = "success" | "error" | number;
+
+// 5. Add type annotations to this function
+// It should accept the Shape type you defined and return a number
+function getArea(shape: Shape, size: number) {
+  switch (shape) {
+    case "circle":
+      return Math.PI * size * size;
+    case "square":
+      return size * size;
+    case "triangle":
+      return (Math.sqrt(3) / 4) * size * size;
+  }
+}
+
+// 6. Add type annotations to this function
+// It should accept the Point type you defined and return a string
+function describePoint(point: Point) {
+  return `(${point.x}, ${point.y})`;
+}
+
+// 7. Add type annotations to this function
+// It should accept the HttpMethod type you defined and a URL string
+// The return type should be a union of 'string' and 'undefined'
+function makeRequest(method: HttpMethod, url: string): string | undefined {
+  // Implementation not required
+  return undefined;
+}
+
+// 8. Create a type for a configuration object
+// It should have a mode property that only allows "development" or "production"
+// and an optional debug property that's a boolean
+type Config = {
+  mode: "development" | "production";
+  debug?: boolean;
+}
+
+// 9. Add type annotations to this function
+// It should accept the Config type you defined
+function setConfig(config: Config) {
+  // Implementation not required
+}
+
+// 10. Create a literal type for valid status values
+type Status = "active" | "inactive" | "suspended";
+
+// Then, refactor the function to use this type
+function updateStatus(status: Status) {
+  if (status === "active" || status === "inactive" || status === "suspended") {
+    // Update the status
+  } else {
+    throw new Error("Invalid status");
+  }
+}
+
+updateStatus("active");
+updateStatus("inactive");
+
+// 11. Create a union type for possible log levels
+type LogLevel = "INFO" | "DEBUG" | "WARNING" | "ERROR";
+
+// Then, refactor the function to use this type and add type annotations
+function log(message: string, level: LogLevel) {
+  const timestamp = new Date().toISOString();
+  console.log(`[${timestamp}] [${level}] ${message}`);
+}
+
+log("Server started", "INFO");
+log("Database connection failed", "ERROR");
+
+// Ignore this line
+export {};