Menganalisis Solusi Orang Lain

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <iomanip>
using namespace std;

struct Solution {
    string author;
    string approach;        // mis. "Two pointers", "Hash map", "Sort + 2 ptr"
    string time_complexity;
    string space_complexity;
    int lines_of_code;
    int runtime_ms;
    int memory_kb;
    string notes;
};

class SolutionAnalyzer {
public:
    void addSolution(const Solution& s) {
        solutions_.push_back(s);
    }

    void compareTable() {
        cout << "=== Tabel Perbandingan Solusi ===\n\n";
        cout << left << setw(15) << "Author"
             << setw(20) << "Approach"
             << setw(15) << "Time"
             << setw(15) << "Space"
             << setw(7)  << "LOC"
             << setw(9)  << "Run(ms)"
             << setw(11) << "Mem(kb)" << "\n";
        cout << "---------------|--------------------|---------------|---------------|-------|---------|----------\n";
        for (const auto& s : solutions_) {
            cout << left << setw(15) << s.author
                 << setw(20) << s.approach
                 << setw(15) << s.time_complexity
                 << setw(15) << s.space_complexity
                 << setw(7)  << s.lines_of_code
                 << setw(9)  << s.runtime_ms
                 << setw(11) << s.memory_kb << "\n";
        }
    }

    void rankBy(string metric) {
        cout << "\n=== Rank by " << metric << " (ascending) ===\n";
        vector<Solution> sorted = solutions_;
        if (metric == "runtime") {
            sort(sorted.begin(), sorted.end(),
                 [](const Solution& a, const Solution& b) {
                     return a.runtime_ms < b.runtime_ms;
                 });
        } else if (metric == "memory") {
            sort(sorted.begin(), sorted.end(),
                 [](const Solution& a, const Solution& b) {
                     return a.memory_kb < b.memory_kb;
                 });
        } else if (metric == "loc") {
            sort(sorted.begin(), sorted.end(),
                 [](const Solution& a, const Solution& b) {
                     return a.lines_of_code < b.lines_of_code;
                 });
        }
        for (size_t i = 0; i < sorted.size(); ++i) {
            cout << "  " << (i+1) << ". " << left << setw(15) << sorted[i].author
                 << " (" << sorted[i].approach << ")\n";
        }
    }

    void lessons() {
        cout << "\n=== Pelajaran dari Perbandingan ===\n";
        for (const auto& s : solutions_) {
            cout << "- [" << s.author << "] " << s.notes << "\n";
        }
    }

private:
    vector<Solution> solutions_;
};

int main() {
    SolutionAnalyzer analyzer;

    // 4 solusi berbeda untuk soal Two Sum (unsorted)
    analyzer.addSolution({"tourist", "Hash map one-pass",
                          "O(n)", "O(n)", 8, 4, 10240,
                          "Hash map memberi lookup O(1); satu pass cukup"});
    analyzer.addSolution({"neal_wu", "Hash map two-pass",
                          "O(n)", "O(n)", 12, 5, 10240,
                          "Lebih jelas; pass 1 build map, pass 2 lookup. Cost: 2x iterasi."});
    analyzer.addSolution({"Benq",    "Sort + two pointers",
                          "O(n log n)", "O(n)", 18, 8, 8192,
                          "Sort mengubah indeks asli; perlu simpan pasangan (val, idx)."});
    analyzer.addSolution({"abc_dude","Brute force",
                          "O(n^2)", "O(1)", 6, 45, 1024,
                          "Tidak praktis untuk n>10^4, tapi baseline penting."});

    analyzer.compareTable();
    analyzer.rankBy("runtime");
    analyzer.rankBy("memory");
    analyzer.rankBy("loc");
    analyzer.lessons();

    cout << "\n=== Strategi Analisis ===\n";
    cout << "1. Identifikasi pola: hash map, two pointers, sort, dll\n";
    cout << "2. Bandingkan time/space complexity - pahami trade-off\n";
    cout << "3. Cek edge case: bagaimana duplikat, input kosong, n=1?\n";
    cout << "4. Pelajari idiom bahasa: mis. C++ unordered_map vs map\n";
    cout << "5. Adaptasi ke konteks lain: mis. bila sorted, ganti hash map jadi 2 ptr\n";
    cout << "6. Catat idiom baru ke 'snippets library' pribadi\n";
    return 0;
}

=== Tabel Perbandingan Solusi ===

Author         Approach            Time           Space          LOC    Run(ms)  Mem(kb)
---------------|--------------------|---------------|---------------|-------|---------|----------
tourist        Hash map one-pass   O(n)           O(n)           8      4        10240
neal_wu        Hash map two-pass   O(n)           O(n)           12     5        10240
Benq           Sort + two pointers O(n log n)     O(n)           18     8        8192
abc_dude       Brute force         O(n^2)         O(1)           6      45       1024

=== Rank by runtime (ascending) ===
  1. tourist         (Hash map one-pass)
  2. neal_wu         (Hash map two-pass)
  3. Benq            (Sort + two pointers)
  4. abc_dude        (Brute force)

=== Rank by memory (ascending) ===
  1. abc_dude        (Brute force)
  2. Benq            (Sort + two pointers)
  3. tourist         (Hash map one-pass)
  4. neal_wu         (Hash map two-pass)

=== Rank by loc (ascending) ===
  1. abc_dude        (Brute force)
  2. tourist         (Hash map one-pass)
  3. neal_wu         (Hash map two-pass)
  4. Benq            (Sort + two pointers)

=== Pelajaran dari Perbandingan ===
- [tourist] Hash map memberi lookup O(1); satu pass cukup
- [neal_wu] Lebih jelas; pass 1 build map, pass 2 lookup. Cost: 2x iterasi.
- [Benq] Sort mengubah indeks asli; perlu simpan pasangan (val, idx).
- [abc_dude] Tidak praktis untuk n>10^4, tapi baseline penting.

=== Strategi Analisis ===
1. Identifikasi pola: hash map, two pointers, sort, dll
2. Bandingkan time/space complexity - pahami trade-off
3. Cek edge case: bagaimana duplikat, input kosong, n=1?
4. Pelajari idiom bahasa: mis. C++ unordered_map vs map
5. Adaptasi ke konteks lain: mis. bila sorted, ganti hash map jadi 2 ptr
6. Catat idiom baru ke 'snippets library' pribadi

[Topic: Hash Map]
[Problem: Two Sum]
[Pattern: One-pass hash map]

Code:
  unordered_map<int,int> seen;
  for (int i = 0; i < nums.size(); ++i) {
      auto it = seen.find(target - nums[i]);
      if (it != seen.end()) return {it->second, i};
      seen[nums[i]] = i;
  }

When to use:
  - Input unsorted
  - Need O(n) lookup
  - Memory O(n) acceptable

Variations:
  - Two Sum II (sorted): two pointers, O(n) time O(1) space
  - Three Sum: sort + two pointers per elemen
  - Four Sum: nested two pointers atau hash map pair sum