Elevate Your Grades with the Best Programming Assignment Help

/**
 * Fetches data from multiple APIs concurrently and combines the results.
 * @param {string[]} urls - An array of API URLs to fetch data from.
 * @returns {Promise<Object>} A promise that resolves to an object containing the combined results.
 */
async function fetchMultipleAPIs(urls) {
  try {
    // Use Promise.all to fetch data from all URLs concurrently
    const responses = await Promise.all(urls.map((url) => fetch(url)));

    // Process each response
    const results = await Promise.all(
      responses.map(async (response, index) => {
        if (!response.ok) {
          throw new Error(
            `HTTP error! status: ${response.status} for URL: ${urls[index]}`
          );
        }
        const data = await response.json();
        return { url: urls[index], data };
      })
    );

    // Combine results into a single object
    const combinedResults = results.reduce((acc, result) => {
      acc[new URL(result.url).pathname] = result.data;
      return acc;
    }, {});

    return combinedResults;
  } catch (error) {
    console.error("Error fetching data:", error);
    throw error;
  }
}

// Example usage:
const apiUrls = [
  "https://api.example.com/users",
  "https://api.example.com/posts",
  "https://api.example.com/comments",
];

fetchMultipleAPIs(apiUrls)
  .then((result) => console.log("Combined API results:", result))
  .catch((error) => console.error("Error:", error));

// actions.js
export const ADD_TO_CART = "ADD_TO_CART";
export const REMOVE_FROM_CART = "REMOVE_FROM_CART";
export const UPDATE_QUANTITY = "UPDATE_QUANTITY";

export const addToCart = (item) => ({
  type: ADD_TO_CART,
  payload: item,
});

export const removeFromCart = (itemId) => ({
  type: REMOVE_FROM_CART,
  payload: itemId,
});

export const updateQuantity = (itemId, quantity) => ({
  type: UPDATE_QUANTITY,
  payload: { itemId, quantity },
});

// reducer.js
import { ADD_TO_CART, REMOVE_FROM_CART, UPDATE_QUANTITY } from "./actions";

const initialState = {
  items: [],
};

export const cartReducer = (state = initialState, action) => {
  switch (action.type) {
    case ADD_TO_CART:
      return {
        ...state,
        items: [...state.items, { ...action.payload, quantity: 1 }],
      };
    case REMOVE_FROM_CART:
      return {
        ...state,
        items: state.items.filter((item) => item.id !== action.payload),
      };
    case UPDATE_QUANTITY:
      return {
        ...state,
        items: state.items.map((item) =>
          item.id === action.payload.itemId
            ? { ...item, quantity: action.payload.quantity }
            : item
        ),
      };
    default:
      return state;
  }
};

// ShoppingCart.js
import React from "react";
import { useSelector, useDispatch } from "react-redux";
import { removeFromCart, updateQuantity } from "./actions";

const ShoppingCart = () => {
  const cartItems = useSelector((state) => state.cart.items);
  const dispatch = useDispatch();

  const handleRemoveItem = (itemId) => {
    dispatch(removeFromCart(itemId));
  };

  const handleUpdateQuantity = (itemId, newQuantity) => {
    dispatch(updateQuantity(itemId, newQuantity));
  };

  return (
    <div>
      <h2>Shopping Cart</h2>
      {cartItems.map((item) => (
        <div key={item.id}>
          <span>{item.name}</span>
          <input
            type="number"
            value={item.quantity}
            onChange={(e) =>
              handleUpdateQuantity(item.id, parseInt(e.target.value))
            }
            min="1"
          />
          <button onClick={() => handleRemoveItem(item.id)}>Remove</button>
        </div>
      ))}
    </div>
  );
};

export default ShoppingCart;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class BoundedBuffer {
    private static final int BUFFER_SIZE = 5;
    private static final int NUM_PRODUCERS = 3;
    private static final int NUM_CONSUMERS = 2;
    private static final int NUM_ITEMS_PER_PRODUCER = 10;

    private static class Producer implements Runnable {
        private final BlockingQueue<Integer> buffer;
        private final int id;

        public Producer(BlockingQueue<Integer> buffer, int id) {
            this.buffer = buffer;
            this.id = id;
        }

        @Override
        public void run() {
            try {
                for (int i = 0; i < NUM_ITEMS_PER_PRODUCER; i++) {
                    int item = (id * 100) + i;
                    buffer.put(item);
                    System.out.println("Producer " + id + " produced: " + item);
                    Thread.sleep((long) (Math.random() * 100));
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }

    private static class Consumer implements Runnable {
        private final BlockingQueue<Integer> buffer;
        private final int id;

        public Consumer(BlockingQueue<Integer> buffer, int id) {
            this.buffer = buffer;
            this.id = id;
        }

        @Override
        public void run() {
            try {
                while (!Thread.currentThread().isInterrupted()) {
                    int item = buffer.take();
                    System.out.println("Consumer " + id + " consumed: " + item);
                    Thread.sleep((long) (Math.random() * 200));
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<Integer> buffer = new ArrayBlockingQueue<>(BUFFER_SIZE);
        ExecutorService executorService = Executors.newFixedThreadPool(NUM_PRODUCERS + NUM_CONSUMERS);

        // Start producers
        for (int i = 0; i < NUM_PRODUCERS; i++) {
            executorService.submit(new Producer(buffer, i));
        }

        // Start consumers
        for (int i = 0; i < NUM_CONSUMERS; i++) {
            executorService.submit(new Consumer(buffer, i));
        }

        // Allow some time for production and consumption
        Thread.sleep(5000);

        // Shutdown the executor service
        executorService.shutdownNow();
        executorService.awaitTermination(1, TimeUnit.SECONDS);

        System.out.println("Simulation completed.");
    }
}

-- Create tables
CREATE TABLE Users (
    UserID INT PRIMARY KEY,
    Username VARCHAR(50) UNIQUE NOT NULL,
    Email VARCHAR(100) UNIQUE NOT NULL,
    CreatedAt TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE Posts (
    PostID INT PRIMARY KEY,
    UserID INT,
    Content TEXT,
    CreatedAt TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (UserID) REFERENCES Users(UserID)
);

CREATE TABLE Follows (
    FollowerID INT,
    FolloweeID INT,
    CreatedAt TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    PRIMARY KEY (FollowerID, FolloweeID),
    FOREIGN KEY (FollowerID) REFERENCES Users(UserID),
    FOREIGN KEY (FolloweeID) REFERENCES Users(UserID)
);

CREATE TABLE Likes (
    UserID INT,
    PostID INT,
    CreatedAt TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    PRIMARY KEY (UserID, PostID),
    FOREIGN KEY (UserID) REFERENCES Users(UserID),
    FOREIGN KEY (PostID) REFERENCES Posts(PostID)
);

-- Create indexes for optimization
CREATE INDEX idx_posts_userid_createdat ON Posts(UserID, CreatedAt);
CREATE INDEX idx_follows_followerid ON Follows(FollowerID);
CREATE INDEX idx_likes_postid ON Likes(PostID);

-- Optimized query to fetch a user's feed
-- This query retrieves posts from users that the given user follows,
-- along with like counts, ordered by creation time
SELECT 
    p.PostID,
    p.Content,
    p.CreatedAt,
    u.Username,
    COUNT(l.UserID) AS LikeCount
FROM 
    Posts p
    INNER JOIN Users u ON p.UserID = u.UserID
    INNER JOIN Follows f ON p.UserID = f.FolloweeID
    LEFT JOIN Likes l ON p.PostID = l.PostID
WHERE 
    f.FollowerID = :user_id -- Replace :user_id with the ID of the user whose feed you're fetching
GROUP BY 
    p.PostID, p.Content, p.CreatedAt, u.Username
ORDER BY 
    p.CreatedAt DESC
LIMIT 50; -- Adjust the limit as needed

#include <atomic>
#include <memory>

template<typename T>
class LockFreeQueue {
private:
    struct Node {
        std::shared_ptr<T> data;
        std::atomic<Node*> next;
        Node() : next(nullptr) {}
    };

    std::atomic<Node*> head;
    std::atomic<Node*> tail;

public:
    LockFreeQueue() {
        Node* dummy = new Node();
        head.store(dummy);
        tail.store(dummy);
    }

    ~LockFreeQueue() {
        while (Node* node = head.load()) {
            head.store(node->next);
            delete node;
        }
    }

    void enqueue(T value) {
        std::shared_ptr<T> newData = std::make_shared<T>(std::move(value));
        Node* newNode = new Node();
        newNode->data = newData;

        while (true) {
            Node* last = tail.load();
            Node* next = last->next.load();

            if (last == tail.load()) {
                if (next == nullptr) {
                    if (last->next.compare_exchange_weak(next, newNode)) {
                        tail.compare_exchange_weak(last, newNode);
                        return;
                    }
                } else {
                    tail.compare_exchange_weak(last, next);
                }
            }
        }
    }

    bool dequeue(T& result) {
        while (true) {
            Node* first = head.load();
            Node* last = tail.load();
            Node* next = first->next.load();

            if (first == head.load()) {
                if (first == last) {
                    if (next == nullptr) {
                        return false;
                    }
                    tail.compare_exchange_weak(last, next);
                } else {
                    if (next->data) {
                        result = std::move(*next->data);
                        if (head.compare_exchange_weak(first, next)) {
                            delete first;
                            return true;
                        }
                    } else {
                        head.compare_exchange_weak(first, next);
                        delete first;
                    }
                }
            }
        }
    }
};

// Example usage:
#include <iostream>
#include <thread>
#include <vector>

int main() {
    LockFreeQueue<int> queue;

    std::vector<std::thread> producers;
    std::vector<std::thread> consumers;

    for (int i = 0; i < 5; ++i) {
        producers.emplace_back([&queue, i]() {
            for (int j = 0; j < 100; ++j) {
                queue.enqueue(i * 100 + j);
            }
        });
    }

    for (int i = 0; i < 5; ++i) {
        consumers.emplace_back([&queue]() {
            int value;
            while (queue.dequeue(value)) {
                std::cout << "Dequeued: " << value << std::endl;
            }
        });
    }

    for (auto& t : producers) t.join();
    for (auto& t : consumers) t.join();

    return 0;
}