Navigating through a series of both open and closed stock positions in an array or chain

Question

Navigating through a series of both open and closed stock positions in an array or chain

I have a list of stock transactions that I need to process in order to determine the final position. The data is coming from a CSV file containing information on buys and sells. My goal is to loop through each transaction and calculate the remaining positions at the end.

At the end of the process, I want to generate an array with multiple objects, each describing a specific trade - for example: buying shares of Twitter (1 open trade), selling all purchased shares (closing the previous trade), making another purchase of Shop (1 open trade), selling a portion of those shares (updating the quantity of the previous trade and creating a new closed trade), then buying more shares and eventually selling all of them (creating a new open trade followed by closing all trades).

Here's an example from the CSV:

{
  Action: 'Buy',
  Symbol: 'SHOP',
  Quantity: '200',
  ...
},
{
  Action: 'Sell',
  Symbol: 'SHOP',
  Quantity: '200',
  ...
},
{
  Action: 'Buy',
  Symbol: 'SHOP',
  Quantity: '50',
  ...
},
{
  Action: 'Sell',
  Symbol: 'SHOP',
  Quantity: '25',
  ...
},
{
  Action: 'Sell',
  Symbol: 'SHOP',
  Quantity: '25',
  ...
},
{
  Action: 'Buy',
  Symbol: 'SHOP',
  Quantity: '1',
  ...
},

This data would be transformed into:

{
  stockTicker: 'SHOP',
  positionStatus: 'CLOSED',
  quantity: 200,
  ...
},
{
  stockTicker: 'SHOP',
  positionStatus: 'CLOSED',
  quantity: 25,
  ...
},
{
  stockTicker: 'SHOP',
  positionStatus: 'CLOSED',
  quantity: 25,
  ...
},
{
  stockTicker: 'SHOP',
  positionStatus: 'OPEN',
  quantity: 1,
  ...
}

The process seems simple if I use a recursive function. I can identify all open trades, match quantities to close trades, but then comes the challenge of handling partial quantity sales. How do I know when to stop iterating? At what point do I consider only open trades remaining as the correct result?

I'm facing uncertainty about knowing when to halt the iteration and search for matching positions.

javascript arrays stock

Answer 1

Answer №1

Instead of using a recursive function, you can achieve the desired result by iterating through your trades array once to construct the positions object.

The trades.reduce(...) method processes the trades array and creates an object where keys represent unique symbols in trades, and values indicate the total quantity held.

The use of Object.entries and .map is optional and provides the convenience of converting the object into an array of objects.

const trades = [
{
  Action: 'Buy',
  Symbol: 'SHOP',
  Quantity: '200',
},
{
  Action: 'Sell',
  Symbol: 'SHOP',
  Quantity: '200',
},
{
  Action: 'Buy',
  Symbol: 'SHOP',
  Quantity: '50',
},
{
  Action: 'Sell',
  Symbol: 'SHOP',
  Quantity: '25',
},
{
  Action: 'Sell',
  Symbol: 'SHOP',
  Quantity: '25',
}
];

const positions = Object.entries(trades.reduce((acc, el) => {
  if (!acc[el.Symbol]) acc[el.Symbol] = 0;
  if (el.Action === "Sell") {
    acc[el.Symbol] -= Number(el.Quantity);
  } else {
    acc[el.Symbol] += Number(el.Quantity);
  }
  return acc;
}, {})).map(([Symbol, Quantity]) => ({Symbol, Quantity}));
console.log(positions);

Answer 2

Instead of using a recursive function, you can achieve the desired result by iterating through your trades array once to construct the positions object.

The trades.reduce(...) method processes the trades array and creates an object where keys represent unique symbols in trades, and values indicate the total quantity held.

The use of Object.entries and .map is optional and provides the convenience of converting the object into an array of objects.

const trades = [
{
  Action: 'Buy',
  Symbol: 'SHOP',
  Quantity: '200',
},
{
  Action: 'Sell',
  Symbol: 'SHOP',
  Quantity: '200',
},
{
  Action: 'Buy',
  Symbol: 'SHOP',
  Quantity: '50',
},
{
  Action: 'Sell',
  Symbol: 'SHOP',
  Quantity: '25',
},
{
  Action: 'Sell',
  Symbol: 'SHOP',
  Quantity: '25',
}
];

const positions = Object.entries(trades.reduce((acc, el) => {
  if (!acc[el.Symbol]) acc[el.Symbol] = 0;
  if (el.Action === "Sell") {
    acc[el.Symbol] -= Number(el.Quantity);
  } else {
    acc[el.Symbol] += Number(el.Quantity);
  }
  return acc;
}, {})).map(([Symbol, Quantity]) => ({Symbol, Quantity}));
console.log(positions);

Answer 3

Answer №2

In tackling this problem, I utilized two arrays: one for buy trades and another for sell trades. By iterating over both arrays, I closed positions that were complete and kept track of those with partial shares sold. Incorporating the Array.some() operator enabled me to streamline the code once the sell order was fully executed. It's worth noting that this solution is designed to handle multiple stock symbols.

Original Array:

investments = [{
  Action: 'Buy',
  Symbol: 'SHOP',
  Quantity: '200',
},{
  Action: 'Sell',
  Symbol: 'SHOP',
  Quantity: '200',
},{
  Action: 'Buy',
  Symbol: 'SHOP',
  Quantity: '50',
},{
  Action: 'Sell',
  Symbol: 'SHOP',
  Quantity: '25',
},{
  Action: 'Sell',
  Symbol: 'SHOP',
  Quantity: '25',
},{
  Action: 'Buy',
  Symbol: 'SHOP',
  Quantity: '1',
}];

Approach:

var buyTrades = investments
  .filter(trade => trade.Action === 'Buy')
  .map(trade => {
  return {
    stockSymbol: trade.Symbol,
    positionStatus: 'OPEN',
    quantity: trade.Quantity,
    remainingQuantity: Number(trade.Quantity)
  }
});

var sellTrades = investments
  .filter(trade => trade.Action === 'Sell')
  .map(trade => {
    return {
      stockSymbol: trade.Symbol,
      quantity: parseInt(trade.Quantity)
    }
});

sellTrades.forEach(sellTrade => {
  var currentSellQuantity = sellTrade.quantity;
  buyTrades.some(buyTrade => {
    if (buyTrade.positionStatus === 'OPEN' && currentSellQuantity !== 0) {
      if (parseInt(buyTrade.remainingQuantity) > currentSellQuantity) {
        buyTrade.remainingQuantity = buyTrade.remainingQuantity - currentSellQuantity;
        currentSellQuantity = 0;
      } else {
        buyTrade.positionStatus = 'CLOSED';
        currentSellQuantity = currentSellQuantity - buyTrade.remainingQuantity;
        delete buyTrade.remainingQuantity;
      }
    } 
    return currentSellQuantity === 0;
  });
});

console.log(buyTrades);

Answer 4

In tackling this problem, I utilized two arrays: one for buy trades and another for sell trades. By iterating over both arrays, I closed positions that were complete and kept track of those with partial shares sold. Incorporating the Array.some() operator enabled me to streamline the code once the sell order was fully executed. It's worth noting that this solution is designed to handle multiple stock symbols.

Original Array:

investments = [{
  Action: 'Buy',
  Symbol: 'SHOP',
  Quantity: '200',
},{
  Action: 'Sell',
  Symbol: 'SHOP',
  Quantity: '200',
},{
  Action: 'Buy',
  Symbol: 'SHOP',
  Quantity: '50',
},{
  Action: 'Sell',
  Symbol: 'SHOP',
  Quantity: '25',
},{
  Action: 'Sell',
  Symbol: 'SHOP',
  Quantity: '25',
},{
  Action: 'Buy',
  Symbol: 'SHOP',
  Quantity: '1',
}];

Approach:

var buyTrades = investments
  .filter(trade => trade.Action === 'Buy')
  .map(trade => {
  return {
    stockSymbol: trade.Symbol,
    positionStatus: 'OPEN',
    quantity: trade.Quantity,
    remainingQuantity: Number(trade.Quantity)
  }
});

var sellTrades = investments
  .filter(trade => trade.Action === 'Sell')
  .map(trade => {
    return {
      stockSymbol: trade.Symbol,
      quantity: parseInt(trade.Quantity)
    }
});

sellTrades.forEach(sellTrade => {
  var currentSellQuantity = sellTrade.quantity;
  buyTrades.some(buyTrade => {
    if (buyTrade.positionStatus === 'OPEN' && currentSellQuantity !== 0) {
      if (parseInt(buyTrade.remainingQuantity) > currentSellQuantity) {
        buyTrade.remainingQuantity = buyTrade.remainingQuantity - currentSellQuantity;
        currentSellQuantity = 0;
      } else {
        buyTrade.positionStatus = 'CLOSED';
        currentSellQuantity = currentSellQuantity - buyTrade.remainingQuantity;
        delete buyTrade.remainingQuantity;
      }
    } 
    return currentSellQuantity === 0;
  });
});

console.log(buyTrades);

Navigating through a series of both open and closed stock positions in an array or chain

Answer №1

Answer №2

Similar questions

The Javascript code is malfunctioning

What causes the absence of data in req.body after submitting a form in quiz.ejs?

How can I implement Javascript for tracking webshop activity and affiliate links across multiple websites?

What is the most effective way to properly define class attributes?

Populate the SPAN tag with the value selected from the dropdown

Combine entities in Firebase when the names match

Error Encountered with Next.js 13.4.1 when using styled-components Button in React Server-Side Rendering

"Unexpected compatibility issues arise when using TypeScript with React, causing errors in props functionality

Angular 6 tutorial: Creating a dynamic side navigation bar with swipe and drag functionality using Angular Material/Bootstrap

Is it possible to establish multiple connections simultaneously using Stomp?

Locate the textbox that pertains to the element currently in focus

Issues with invoking C# event through ajax communication

Transforming a bitmap into a byte array, encoding it into a string, and then reversing the process

Converting character array to a double after reading from a file

Creating a fixed subarray in Java

Is it possible to schedule a periodic GET request on the server-side without utilizing the client-side or frontend?

What could be the reason that the painting application is not functioning properly on mobile devices?

How can I display the value entered in a text input field when using ajax upload?

What steps do I need to take in order to set up a private Git repository for my current project, specifically within a certain

Is there a discrepancy between the data posted using jQuery and the payload in Json?