Ticker Plant

#include <cstdio>
#include <cstring>
#include <map>
#include <vector>
#include <string>
#include <algorithm>

struct Trade {
    long long ts_seconds;
    std::string symbol;
    double price;
    long long qty;
};

struct Bar {
    double open, high, low, close, vwap_num;
    long long volume, count;
};

int main() {
    int N;
    scanf("%d", &N);

    // key = (ts_seconds, symbol)
    std::map<std::pair<long long, std::string>, Bar> bars;
    char line[512];

    for (int i = 0; i < N; i++) {
        scanf(" %[^\n]", line);
        // Parse exchange-specific format:
        // NYSE|ns|SYM|price|qty|side
        // NASDAQ|us|SYM|side|qty|price
        // BATS|ms|SYM|price|qty|side|trade_id
        // IEX|sec.us|SYM|price|qty|side

        // Normalize timestamp to seconds
        // Aggregate into OHLCV bar with VWAP
    }

    // Count unique symbols and bars
    // Output header: num_symbols num_bars
    // Output sorted bars
    return 0;
}

import sys
from collections import defaultdict

N = int(input())

# bars[(ts_sec, symbol)] = {open, high, low, close, volume, vwap_num, count}
bars = {}

for _ in range(N):
    line = input().strip()
    parts = line.split('|')
    exchange = parts[0]

    # Parse based on exchange format
    if exchange == 'NYSE':
        ts_ns = int(parts[1])
        symbol, price, qty, side = parts[2], float(parts[3]), int(parts[4]), parts[5]
        ts_sec = ts_ns // 1_000_000_000
    elif exchange == 'NASDAQ':
        ts_us = int(parts[1])
        symbol, side, qty, price = parts[2], parts[3], int(parts[4]), float(parts[5])
        ts_sec = ts_us // 1_000_000
    elif exchange == 'BATS':
        ts_ms = int(parts[1])
        symbol, price, qty, side = parts[2], float(parts[3]), int(parts[4]), parts[5]
        ts_sec = ts_ms // 1_000
    elif exchange == 'IEX':
        ts_dec = float(parts[1])
        symbol, price, qty, side = parts[2], float(parts[3]), int(parts[4]), parts[5]
        ts_sec = int(ts_dec)

    key = (ts_sec, symbol)
    if key not in bars:
        bars[key] = {'open': price, 'high': price, 'low': price, 'close': price,
                     'volume': qty, 'vwap_num': price * qty, 'count': 1}
    else:
        b = bars[key]
        b['high'] = max(b['high'], price)
        b['low'] = min(b['low'], price)
        b['close'] = price
        b['volume'] += qty
        b['vwap_num'] += price * qty
        b['count'] += 1

symbols = set()
for (ts, sym) in bars:
    symbols.add(sym)

sorted_keys = sorted(bars.keys())
print(f"{len(symbols)} {len(sorted_keys)}")
for (ts, sym) in sorted_keys:
    b = bars[(ts, sym)]
    vwap = b['vwap_num'] / b['volume'] if b['volume'] > 0 else 0
    print(f"{ts} {sym} {b['open']:.6f} {b['high']:.6f} {b['low']:.6f} {b['close']:.6f} {b['volume']} {vwap:.6f} {b['count']}")

use std::io::{self, BufRead, Write, BufWriter};
use std::collections::BTreeMap;

fn main() {
    let stdin = io::stdin();
    let stdout = io::stdout();
    let mut out = BufWriter::new(stdout.lock());
    let mut lines = stdin.lock().lines();

    let n: usize = lines.next().unwrap().unwrap().trim().parse().unwrap();

    // BTreeMap for sorted output: (ts_sec, symbol) -> bar data
    // Parse each exchange format, normalize timestamps, aggregate OHLCV
    // Output: header + sorted bars

    for _ in 0..n {
        let line = lines.next().unwrap().unwrap();
        let parts: Vec<&str> = line.trim().split('|').collect();
        let exchange = parts[0];
        // Parse based on exchange...
    }
}

import java.util.*;
import java.io.*;

public class Solution {
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int N = Integer.parseInt(br.readLine().trim());

        // TreeMap for sorted output: "ts_sec|symbol" -> bar data
        TreeMap<String, double[]> bars = new TreeMap<>();

        for (int i = 0; i < N; i++) {
            String line = br.readLine().trim();
            String[] parts = line.split("\\|");
            String exchange = parts[0];

            // Parse based on exchange format
            // NYSE: ns, NASDAQ: us, BATS: ms, IEX: decimal seconds
            // Normalize to seconds, aggregate OHLCV + VWAP
        }

        // Output header: num_symbols num_bars
        // Output sorted bars
    }
}