PSLang

AC를

코딩을

실행을

디버깅을

AC를

코딩을

실행을

— 더 빠르게.

PSLang.

PSLang은 문제풀이(Problem Solving)를 하는 사람들에게
최적의 경험을 제공하는 데에 초점을 맞춘 언어입니다.

Python만큼 쉬운 구현.
C++만큼 빠른 실행.

PSLang의 기반은 Python의 하위 문법입니다.
Python을 알고 있으시다면 새 언어를 배울 필요 없습니다.
작성된 코드는 C++로 변환되어, 모든 문제풀이 플랫폼에
별도의 과정 없이 곧바로 제출할 수 있습니다.

def main():
    a = read_int(1, 9)
    b = read_int(1, 9)
    print(a + b)
    return 0

#include <cstdio>
using namespace std;

inline int read_int(int s, int e) {
    int x;
    scanf("%d", &x);
    return x;
}

inline void print_int(int x) {
    printf("%d\n", x);
}

int main() {
    int a = read_int(1, 9);
    int b = read_int(1, 9);
    print_int(a + b);
    return 0;
}

미리 구현된 코드에서
멈추지 않습니다.

미리 구현된 알고리즘 코드를 당연히 사용할 수 있습니다.
여기에 그치지 않고, 부타입을 도입하여 프로그램이
잘못될 수 있는 부분을 실행 없이 확인하는 기술을 탑재했습니다.

def main():
    n = read_int(1, 300_000)
    m = read_int(1, 300_000)
    segtree = SegmentTreeAdd(n)
    for _ in range(m):
        a = read_int(1, 2)
        if a == 1:
            i = read_int(1, n)
            x = read_int(1, 3_000)
            segtree.update(iTypeError: type int(1, 300000) does not match
argument 1 of attribute update, x)
        else:
            a = read_int(1, n)
            b = read_int(1, n)
            print(segtree.query(a, b))
    return 0

def main():
    n = read_int(1, 300_000)
    m = read_int(1, 300_000)
    segtree = SegmentTreeAdd(n + 1)
    for _ in range(m):
        a = read_int(1, 2)
        if a == 1:
            i = read_int(1, n)
            x = read_int(1, 3_000)
            segtree.update(i, x)
        else:
            a = read_int(1, n)
            b = read_int(1, n)
            print(segtree.query(a, b))
    return 0

#include <cstdio>
#include <ranges>
#include <vector>
using namespace std;

inline int read_int(int s, int e) {
    int x;
    scanf("%d", &x);
    return x;
}

inline void print_int(int x) {
    printf("%d\n", x);
}

inline auto range(int a) {
    return views::iota(0, a);
}

template <typename _T> class PSArray: public vector<_T> {
public:
    PSArray(): vector<_T>() {}
    PSArray(size_t n, const _T& val = _T()): vector<_T>(n, val) {}
    template <class InputIterator> PSArray(InputIterator first, InputIterator last): vector<_T>(first, last) {}
    PSArray(const vector<_T>& x): vector<_T>(x) {}
    PSArray(int n): vector<_T>(n) {}
    template <typename _U> operator PSArray<_U>() {
        size_t sz = this->size();
        PSArray<_U> result(sz);
        for (size_t i=0; i<sz; ++i) {
            result[i] = (*this)[i];
        }
        return result;
    }
};

template<typename _T> class SegmentTreeAdd {
    int n;
    PSArray<_T> segtree;
    _T update(int index, _T value, int n, int s, int e) {
        if (index < s || e < index) return this->segtree[n];
        if (s == e) return this->segtree[n] = value;
        int mid = (s + e) >> 1;
        _T left_val = update(index, value, n << 1, s, mid);
        _T right_val = update(index, value, (n << 1) | 1, mid + 1, e);
        return this->segtree[n] = left_val + right_val;
    }
    _T query(int start, int end, int n, int s, int e) {
        if (end < s || e < start) return static_cast<_T>(0);
        if (s == e) return this->segtree[n];
        int mid = (s + e) >> 1;
        _T left_val = query(start, end, n << 1, s, mid);
        _T right_val = query(start, end, (n << 1) | 1, mid + 1, e);
        return left_val + right_val;
    }
public:
    SegmentTreeAdd(int n = 0): n(n) {
        if (n > 0) segtree.resize(4 * n + 1);
    }
    template <typename _U> friend class SegmentTreeAdd;
    template <typename _U> operator SegmentTreeAdd<_U>() {
        SegmentTreeAdd<_U> result(0);
        result.n = this->n;
        result.segtree = this->segtree;
        return result;
    }
    void update(int index, _T value) {
        update(index + 1, value, 1, 1, n);
    }
    _T query(int start, int end) {
        return query(start + 1, end + 1, 1, 1, n);
    }
};

typedef SegmentTreeAdd<int> SegmentTreeAddInt;

int main() {
    int n = read_int(1, 300000);
    int m = read_int(1, 300000);
    SegmentTreeAdd<int> segtree = SegmentTreeAddInt(n + 1);
    for (int _: range(m)) {
        int a = read_int(1, 2);
        if (a == 1) {
            int i = read_int(1, n);
            int x = read_int(1, 3000);
            segtree.update(i, x);
        } else {
            a = read_int(1, n);
            int b = read_int(1, n);
            print_int(segtree.query(a, b));
        }
    }
    return 0;
}

풀 때도, 만들 때도.

PSLang은 문제를 푸는 경험뿐 아니라
문제를 만드는 경험 역시 향상합니다.
정해에서 Validator, Generator를 바로 만들 수 있고,
다른 코드와의 Stress 역시 시행할 수 있습니다.

def main():
    MAX_VAL = 1_000_000_000
    n = read_int(1, 300_000)
    arr = io.read_iarr(n, -MAX_VAL, MAX_VAL)
    ans = -MAX_VAL
    subans = 0
    for x in arr:
        if subans < 0:
            subans = x
        else:
            subans += x
        if ans < subans:
            ans = subans
    print(ans)
    return 0

#include <cstdio>
#include <vector>
using namespace std;

inline int read_int(int s, int e) {
    int x;
    scanf("%d", &x);
    return x;
}

template <typename _T> class PSArray: public vector<_T> {
public:
    PSArray(): vector<_T>() {}
    PSArray(size_t n, const _T& val = _T()): vector<_T>(n, val) {}
    template <class InputIterator> PSArray(InputIterator first, InputIterator last): vector<_T>(first, last) {}
    PSArray(const vector<_T>& x): vector<_T>(x) {}
    PSArray(int n): vector<_T>(n) {}
    template <typename _U> operator PSArray<_U>() {
        size_t sz = this->size();
        PSArray<_U> result(sz);
        for (size_t i=0; i<sz; ++i) {
            result[i] = (*this)[i];
        }
        return result;
    }
};

inline void print_lli(long long x) {
    printf("%lld\n", x);
}

struct {
    PSArray<int> read_iarr(int n, int a, int b) {
        PSArray<int> result(n);
        for (int &x: result) scanf("%d", &x);
        return result;
    }
} io;

int main() {
    int MAX_VAL = 1000000000;
    int n = read_int(1, 300000);
    PSArray<int> arr = io.read_iarr(n, -MAX_VAL, MAX_VAL);
    long long ans = -MAX_VAL;
    long long subans = 0;
    for (int x: arr) {
        if (subans < 0) {
            subans = x;
        } else {
            subans += x;
        }
        if (ans < subans) {
            ans = subans;
        }
    }
    print_lli(ans);
    return 0;
}

#include "testlib.h"
#include <vector>
using namespace std;

inline void print_lli(long long x) { }

template <typename _T> class PSArray: public vector<_T> {
public:
    PSArray(): vector<_T>() {}
    PSArray(size_t n, const _T& val = _T()): vector<_T>(n, val) {}
    template <class InputIterator> PSArray(InputIterator first, InputIterator last): vector<_T>(first, last) {}
    PSArray(const vector<_T>& x): vector<_T>(x) {}
    PSArray(int n): vector<_T>(n) {}
    template <typename _U> operator PSArray<_U>() {
        size_t sz = this->size();
        PSArray<_U> result(sz);
        for (size_t i=0; i<sz; ++i) {
            result[i] = (*this)[i];
        }
        return result;
    }
};

inline int read_int(int s, int e) {
    int x = inf.readInt(s, e);
    inf.readEoln();
    return x;
}

struct {
    PSArray<int> read_iarr(int n, int a, int b) {
        std::vector<int> result = inf.readInts(n, a, b);
        inf.readEoln();
        return result;
    }
} io;

int main(int argc, char *argv[]) {
    registerValidation(argc, argv);
    int MAX_VAL = 1000000000;
    int n = read_int(1, 300000);
    PSArray<int> arr = io.read_iarr(n, -MAX_VAL, MAX_VAL);
    long long ans = -MAX_VAL;
    long long subans = 0;
    for (int x: arr) {
        if (subans < 0) {
            subans = x;
        } else {
            subans += x;
        }
        if (ans < subans) {
            ans = subans;
        }
    }
    print_lli(ans);
    inf.readEof();
    return 0;
}

#include "testlib.h"
#include <cstdio>
#include <vector>
using namespace std;

inline int read_int(int s, int e) {
    int x = rnd.next(s, e);
    printf("%d\n", x);
    return x;
}

template <typename _T> class PSArray: public vector<_T> {
public:
    PSArray(): vector<_T>() {}
    PSArray(size_t n, const _T& val = _T()): vector<_T>(n, val) {}
    template <class InputIterator> PSArray(InputIterator first, InputIterator last): vector<_T>(first, last) {}
    PSArray(const vector<_T>& x): vector<_T>(x) {}
    PSArray(int n): vector<_T>(n) {}
    template <typename _U> operator PSArray<_U>() {
        size_t sz = this->size();
        PSArray<_U> result(sz);
        for (size_t i=0; i<sz; ++i) {
            result[i] = (*this)[i];
        }
        return result;
    }
};

inline void print_lli(long long x) {
    printf("%lld\n", x);
}

struct {
    PSArray<int> read_iarr(int n, int a, int b) {
        std::vector<int> result;
        for (int i=0; i<n; ++i) {
            int x = rnd.next(a, b);
            result.push_back(x);
            printf("%d%c", x, i == n - 1 ? '\n' : ' ');
        }
        return result;
    }
} io;

int main(int argc, char *argv[]) {
    registerGen(argc, argv, 1);
    int MAX_VAL = 1000000000;
    int n = read_int(1, 300000);
    PSArray<int> arr = io.read_iarr(n, -MAX_VAL, MAX_VAL);
    long long ans = -MAX_VAL;
    long long subans = 0;
    for (int x: arr) {
        if (subans < 0) {
            subans = x;
        } else {
            subans += x;
        }
        if (ans < subans) {
            ans = subans;
        }
    }
    print_lli(ans);
    return 0;
}

향상된 문제풀이를 곧
체험할 수 있습니다.

PSLang은 2025년 5월 중 실험할 수 있도록
알파 테스트를 진행할 예정입니다.