# List - mutable listmy_list = [1, 2, 3]           # Create a listmy_list.append(4)             # Append an elementmy_list[1] = 10               # Modify the element at index 1subset = my_list[1:3]         # Slice: elements from index 1 to 3 (exclusive)# Tuple - immutable tuplemy_tuple = (1, 2, 3)          # Create a tupleitem = my_tuple[0]            # Index access# Set - deduplicated collectionmy_set = {1, 2, 3}            # Create a setmy_set.add(4)                 # Add an elementunion = set1 | set2           # Unionintersection = set1 & set2    # Intersection# Dict - key-value pairsmy_dict = {"a": 1, "b": 2}    # Create a dictvalue = my_dict.get("c", 0)   # Get a value, default to 0 if key missingmy_dict["d"] = 4              # Add or update a key-value pairkeys = my_dict.keys()         # Get all keys

// Slice - dynamic array, variable lengthslice := []int{1, 2, 3}        // Create and initialize a sliceslice = append(slice, 4)       // Append an elementslice[1] = 10                  // Modify the element at index 1subset := slice[1:3]           // Slice: elements from index 1 to 3 (exclusive)// Array - fixed-length arrayarr := [3]int{1, 2, 3}         // Create an int array of length 3arr[0] = 5                     // Modify an element// Map - hash table, key-value storagem := map[string]int{"a": 1, "b": 2}  // Create and initialize a mapvalue, exists := m["c"]              // Get value and existence flag by keym["d"] = 4                           // Add or update a key-value pairdelete(m, "a")                       // Delete a key-value pair// Stack operations (implemented with a slice)stack := []int{}               // Create an empty stackstack = append(stack, 1)       // pushtop := stack[len(stack)-1]    // peek: view the top elementstack = stack[:len(stack)-1]  // pop// Queue operations (implemented with a slice)queue := []int{}              // Create an empty queuequeue = append(queue, 1)       // enqueuefront := queue[0]             // peek: view the front elementqueue = queue[1:]             // dequeue

// Arrayconst arr = [1, 2, 3];                 // Create an arrayarr.push(4);                          // Append an elementarr[1] = 10;                          // Modify the element at index 1const subset = arr.slice(1, 3);       // Slice: elements from index 1 to 3 (exclusive)arr.forEach(x => console.log(x));     // Iterate over the arrayconst mapped = arr.map(x => x * 2);   // Map: transform each elementconst filtered = arr.filter(x => x > 1); // Filter: keep matching elements// Objectconst obj = {a: 1, b: 2};             // Create an objectconst value = obj.c || 0;             // Get a property, default if missingobj.d = 4;                            // Add or update a propertyconst keys = Object.keys(obj);        // Get all keysconst values = Object.values(obj);    // Get all values// Set - deduplicated collectionconst set = new Set([1, 2, 2, 3]);    // Create a setset.add(4);                           // Add an elementset.has(1);                           // Check whether an element existsset.delete(1);                        // Delete an element// Map - key-value mappingconst map = new Map([['a', 1], ['b', 2]]); // Create a mapmap.set('c', 3);                       // Set a key-value pairmap.get('a');                          // Get a valuemap.has('a');                          // Check whether a key exists

// List (ArrayList)List<Integer> list = new ArrayList<>();list.add(1);list.add(2);list.set(1, 10);List<Integer> subList = list.subList(0, 2);list.remove(Integer.valueOf(1));// Set (HashSet)Set<Integer> set = new HashSet<>();set.add(1);set.contains(1);set.remove(1);// Map (HashMap)Map<String, Integer> map = new HashMap<>();map.put("a", 1);map.getOrDefault("c", 0);map.containsKey("a");Set<String> keys = map.keySet();// Queue (LinkedList)Queue<Integer> queue = new LinkedList<>();queue.offer(1);Integer front = queue.poll();// Stack (Stack)Stack<Integer> stack = new Stack<>();stack.push(1);Integer top = stack.pop();Integer peek = stack.peek();

-- Table as Arrayarr = {1, 2, 3}table.insert(arr, 4)arr[2] = 10table.remove(arr, 1)-- Table as Dictionarydict = {a = 1, b = 2}dict["c"] = 3dict.d = 4value = dict.a or 0-- Common table operationscount = #arrfor i, v in ipairs(arr) do    print(i, v)endfor k, v in pairs(dict) do    print(k, v)end

# Variablesx = 10                      # Integername = "Python"             # Stringis_active = True            # Boolean# Operators+, -, *, /, //, %, **       # Arithmetic: add, subtract, multiply, divide, floor divide, modulo, power==, !=, >, <, >=, <=        # Comparison operatorsand, or, not                # Logical operatorsin, is                      # Membership test, identity test# Functionsdef greet(name):    return f"Hello, {name}"

// Variablesvar x int = 10                           // Full declarationvar name string = "Go"isActive := true                        // Short declaration (type inferred)// Operators+, -, *, /, %                           // Arithmetic operators==, !=, >, <, >=, <=                   // Comparison operators&&, ||, !                               // Logical operators// Functionsfunc greet(name string) string {         // Parameter and return types    return fmt.Sprintf("Hello, %s", name)}

// Variableslet x = 10;                           // Mutable variableconst name = "JavaScript";             // Immutable constantlet isActive = true;                   // Boolean// Operators+, -, *, /, %                         // Arithmetic operators==, ===, !=, !==, >, <, >=, <=       // Comparison (== compares values, === compares type and value)&&, ||, !                             // Logical operatorsin, instanceof                        // Membership test, type test// Functionsfunction greet(name) {    return `Hello, ${name}`;}

// Variablesint x = 10;                      // int typeString name = "Java";             // String typeboolean isActive = true;          // boolean type// Operators+, -, *, /, %                    // Arithmetic operators==, !=, >, <, >=, <=            // Comparison operators&&, ||, !                        // Logical operatorsinstanceof                       // Type test// Methodspublic String greet(String name) {    return "Hello, " + name;}

-- VariablesglobalVar = 10              -- Global variablelocal localVar = 20         -- Local variable (recommended)local name = "Lua"local isActive = true-- Operators+, -, *, /, %, ^            -- Arithmetic operators (^ is power)==, ~=, >, <, >=, <=        -- Comparison operators (~= is not-equal)and, or, not                -- Logical operators-- Functionsfunction greet(name)    return "Hello, " .. name   -- .. is string concatenationend

# If-elif-elseif condition:    passelif condition2:    passelse:    pass# Ternary operatorresult = "yes" if condition else "no"# Nested conditionsif outer_condition:    if inner_condition:        pass    else:        pass

// If-else if-elseif condition {} else if condition2 {} else {}// If with initializationif x := getValue(); x > 0 {    fmt.Println("positive")} else {    fmt.Println("non-positive")}// Switch statementswitch value {case 1:    fmt.Println("one")case 2:    fmt.Println("two")default:    fmt.Println("other")}

// If-else if-elseif (condition) {} else if (condition2) {} else {}// Ternary operatorresult = condition ? "yes" : "no";// Switch statementswitch (value) {    case 1:        console.log("one");        break;    case 2:        console.log("two");        break;    default:        console.log("other");}

// If-else if-elseif (condition) {} else if (condition2) {} else {}// Ternary operatorresult = condition ? "yes" : "no";// Switch statementswitch (value) {    case 1:        System.out.println("one");        break;    case 2:        System.out.println("two");        break;    default:        System.out.println("other");}// Switch expressions (Java 14+)String message = switch (value) {    case 1 -> "one";    case 2 -> "two";    default -> "other";};

-- If-elseif-elseif condition thenelseif condition2 thenelseend-- Nested conditionsif outer_condition then    if inner_condition then    else    endend-- No ternary operator in Lua-- Use if-else or logical operatorsresult = condition and "yes" or "no"

# For loop with rangefor i in range(10):         # 0 to 9    passfor i in range(1, 11):     # 1 to 10    passfor i in range(0, 10, 2):  # 0, 2, 4, 6, 8    pass# For loop over iterablefor item in items:    passfor index, item in enumerate(items):    pass# While loopwhile condition:    pass# Loop controlfor i in range(10):    if i == 5:        break    # Exit loop    if i == 3:        continue # Skip to next iteration

// Traditional for loopfor i := 0; i < 10; i++ {}// For range over slice/arrayfor index, item := range items {}// For range over mapfor key, value := range m {}// While loop (Go only has for)for condition {}// Infinite loopfor {}// Loop controlfor i := 0; i < 10; i++ {    if i == 5 {        break    // Exit loop    }    if i == 3 {        continue // Skip to next iteration    }}

// Traditional for loopfor (let i = 0; i < 10; i++) {}// For...of loop (iterables)for (const item of items) {}// For...in loop (object properties)for (const key in obj) {}// While loopwhile (condition) {}// Do-while loopdo {} while (condition);// Loop controlfor (let i = 0; i < 10; i++) {    if (i === 5) {        break;    // Exit loop    }    if (i === 3) {        continue; // Skip to next iteration    }}

// Traditional for loopfor (int i = 0; i < 10; i++) {}// Enhanced for loopfor (int item : items) {}// While loopwhile (condition) {}// Do-while loopdo {} while (condition);// Loop controlfor (int i = 0; i < 10; i++) {    if (i == 5) {        break;    // Exit loop    }    if (i == 3) {        continue; // Skip to next iteration    }}// Labeled loops (for nested loops)outer: for (int i = 0; i < 3; i++) {    inner: for (int j = 0; j < 3; j++) {        if (i == 1 && j == 1) {            break outer; // Exit outer loop        }    }}

-- Numeric for loopfor i = 1, 10 do          -- 1 to 10endfor i = 1, 10, 2 do       -- 1, 3, 5, 7, 9end-- Generic for loop (ipairs for arrays)for i, v in ipairs(arr) doend-- Generic for loop (pairs for dictionaries)for k, v in pairs(dict) doend-- While loopwhile condition doend-- Repeat until loop (like do-while)repeatuntil condition-- Loop controlfor i = 1, 10 do    if i == 5 then        break    -- Exit loop    end    if i == 3 then        -- No continue in Lua, use if    endend

# Lambda - anonymous functionadd = lambda x, y: x + y# Classesclass Person:    def __init__(self, name):   # Constructor        self.name = name    def greet(self):             # Instance method        return f"Hello, {self.name}"# List Comprehensionsquared = [x**2 for x in range(10)]  # Squares of 0-9

// Multiple return valuesfunc divide(a, b int) (int, error) {     // Return a result and an error    if b == 0 {        return 0, errors.New("division by zero")  // Return an error    }    return a / b, nil                   // Return the result, error is nil}// Structstype Person struct {    Name string                          // Struct fields    Age  int}func (p Person) Greet() string {        // Method (value receiver)    return fmt.Sprintf("Hello, %s", p.Name)}// Goroutinesgo func() {                             // The go keyword starts a goroutine    fmt.Println("goroutine")}()// Channels - communication between goroutinesch := make(chan int)                    // Create a channelgo func() {    ch <- 1                             // Send data into the channel}()value := <-ch                           // Receive data from the channel

// Ternary operatorresult = condition ? a : b;// Arrow Functionconst greet = (name) => `Hello, ${name}`;// Objectsconst person = {    name: "John",    greet() {                         // Object method        return `Hello, ${this.name}`;    }};// Array methodsitems.forEach(item => console.log(item)); // Iterate over the arrayconst mapped = items.map(x => x * 2);     // Map the arrayconst filtered = items.filter(x => x > 1); // Filter the array