smallest-string-with-swaps py3

.scripts/addnew

@@ -4,7 +4,7 @@ import Turndown from "turndown";
 import * as cheerio from "cheerio";
 import { client, gql } from "./graphql.mjs";
 
-const langExt = { python3: "py", nodejs: "js", cpp: "cpp" };
+const langExt = { python3: "py", nodejs: "js", cpp: "cpp", sql: "sql" };
 
 const link = await question("Enter leetcode problem link: ");
 const titleSlug = path.basename(new URL(link).pathname);

1308_smallest-string-with-swaps/README.md

@@ -0,0 +1,42 @@
+You are given a string `s`, and an array of pairs of indices in the string `pairs` where `pairs[i] = [a, b]` indicates 2 indices(0-indexed) of the string.
+
+You can swap the characters at any pair of indices in the given `pairs` **any number of times**.
+
+Return the lexicographically smallest string that `s` can be changed to after using the swaps.
+
+**Example 1:**
+
+    Input: s = "dcab", pairs = [[0,3],[1,2]]
+    Output: "bacd"
+    Explaination: 
+    Swap s[0] and s[3], s = "bcad"
+    Swap s[1] and s[2], s = "bacd"
+    
+
+**Example 2:**
+
+    Input: s = "dcab", pairs = [[0,3],[1,2],[0,2]]
+    Output: "abcd"
+    Explaination: 
+    Swap s[0] and s[3], s = "bcad"
+    Swap s[0] and s[2], s = "acbd"
+    Swap s[1] and s[2], s = "abcd"
+
+**Example 3:**
+
+    Input: s = "cba", pairs = [[0,1],[1,2]]
+    Output: "abc"
+    Explaination: 
+    Swap s[0] and s[1], s = "bca"
+    Swap s[1] and s[2], s = "bac"
+    Swap s[0] and s[1], s = "abc"
+    
+
+**Constraints:**
+
+*   `1 <= s.length <= 10^5`
+*   `0 <= pairs.length <= 10^5`
+*   `0 <= pairs[i][0], pairs[i][1] < s.length`
+*   `s` only contains lower case English letters.
+
+https://leetcode.com/problems/smallest-string-with-swaps

1308_smallest-string-with-swaps/python3/solution.py

@@ -0,0 +1,52 @@
+from collections import defaultdict
+
+class Solution:
+    def smallestStringWithSwaps(self, s: str, pairs: List[List[int]]) -> str:
+        '''
+        Key idea: if (a, b) indexes can be swapped and (b, c) indexes can
+        be swapped, then (a, c) can be swapped so infinite swap across (a, b, c).
+        Can be expanded to cover any other letters that are swappable.
+        '''
+        
+        # Make the adjacency list
+        swapmap = defaultdict(list)
+        
+        for i, j in pairs:
+            swapmap[i].append(j)
+            swapmap[j].append(i)
+            
+        
+        def dfs(s, vertex, chars, vertices):
+            chars.append(s[vertex])
+            vertices.append(vertex)
+            
+            visited.add(vertex)
+            
+            for neighbor in swapmap[vertex]:
+                if neighbor not in visited:
+                    dfs(s, neighbor, chars, vertices)
+        
+        
+        output = [''] * len(s)
+        visited = set()
+        
+        for vertex, _ in enumerate(s):
+            if vertex not in visited:
+                connected_chars = []
+                connected_vertices = []
+                
+                dfs(s, vertex, connected_chars, connected_vertices)
+                
+                # This might seem confusing but remember that if we find one character
+                # with the `vertex` connected (i.e swappable) with other characters, then
+                # they can all be swapped with each other infinite times. Our goal is to
+                # get the lexicographically smallest string (i.e most sorted) from doing
+                # these allowed swaps. Hence, we can go ahead and safely sort the chars
+                # obtained from DFS of vertex.
+                connected_chars.sort()
+                connected_vertices.sort()
+                
+                for i, connected_vertex in enumerate(connected_vertices):
+                    output[connected_vertex] = connected_chars[i]
+        
+        return ''.join(output)

1541_top-travellers/README.md

@@ -0,0 +1,78 @@
+Table: `Users`
+
+    +---------------+---------+
+    | Column Name   | Type    |
+    +---------------+---------+
+    | id            | int     |
+    | name          | varchar |
+    +---------------+---------+
+    id is the primary key for this table.
+    name is the name of the user.
+    
+
+Table: `Rides`
+
+    +---------------+---------+
+    | Column Name   | Type    |
+    +---------------+---------+
+    | id            | int     |
+    | user_id       | int     |
+    | distance      | int     |
+    +---------------+---------+
+    id is the primary key for this table.
+    user_id is the id of the user who traveled the distance "distance".
+    
+
+Write an SQL query to report the distance traveled by each user.
+
+Return the result table ordered by `travelled_distance` in **descending order**, if two or more users traveled the same distance, order them by their `name` in **ascending order**.
+
+The query result format is in the following example.
+
+**Example 1:**
+
+    Input: 
+    Users table:
+    +------+-----------+
+    | id   | name      |
+    +------+-----------+
+    | 1    | Alice     |
+    | 2    | Bob       |
+    | 3    | Alex      |
+    | 4    | Donald    |
+    | 7    | Lee       |
+    | 13   | Jonathan  |
+    | 19   | Elvis     |
+    +------+-----------+
+    Rides table:
+    +------+----------+----------+
+    | id   | user_id  | distance |
+    +------+----------+----------+
+    | 1    | 1        | 120      |
+    | 2    | 2        | 317      |
+    | 3    | 3        | 222      |
+    | 4    | 7        | 100      |
+    | 5    | 13       | 312      |
+    | 6    | 19       | 50       |
+    | 7    | 7        | 120      |
+    | 8    | 19       | 400      |
+    | 9    | 7        | 230      |
+    +------+----------+----------+
+    Output: 
+    +----------+--------------------+
+    | name     | travelled_distance |
+    +----------+--------------------+
+    | Elvis    | 450                |
+    | Lee      | 450                |
+    | Bob      | 317                |
+    | Jonathan | 312                |
+    | Alex     | 222                |
+    | Alice    | 120                |
+    | Donald   | 0                  |
+    +----------+--------------------+
+    Explanation: 
+    Elvis and Lee traveled 450 miles, Elvis is the top traveler as his name is alphabetically smaller than Lee.
+    Bob, Jonathan, Alex, and Alice have only one ride and we just order them by the total distances of the ride.
+    Donald did not have any rides, the distance traveled by him is 0.
+
+https://leetcode.com/problems/top-travellers/

1541_top-travellers/sql/solution.sql

@@ -0,0 +1,6 @@
+# Write your MySQL query statement below
+SELECT Users.name as name, COALESCE(SUM(distance), 0) as travelled_distance
+FROM Users
+LEFT JOIN Rides ON Users.id = Rides.user_id
+GROUP BY Users.id
+ORDER BY travelled_distance DESC, name ASC;