Anonymní profil paya – Programujte.com

#7 Sefiros

Jak jsem uz napsal, pridani "zavisle" smycky na resitelnosti soustavy nic nezmeni. Proto se ji take rika zavisla, protoze ve vysledne soustave rovnic vytvori rovnici linearne zavislou na zbylych rovnicich. Predpokladam, ze nekdo s minimalni znalosti linearni algebry, resitelnosti soustav linearnich rovnic a Kirchhoffovych zakonu si to dokaze sam.

#5 Sefiros

To je jedno. Hlavni je, aby se v grafu obvodu nasly vsechny, resp. aby vsechny hrany byly v nejake smycce. V nejhorsim pripade bude vysledna soustava pro proudu preurcena, ale konzistentni, cili resitelna!

Do baze 36 by to stacilo? :-P   

#include <iostream>
#include <string>
#include <cassert>

namespace lol {

    static const std::string digits("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ");

    template<typename T>
    std::string to_string(T number, size_t base)
    {
        assert((base > 1) && (base <= digits.length()));
        std::string s;
        do {
            s.insert(0, 1, digits[number % base]);
            number /= base;
        } while (number);
        return s;
    }

    template<typename T>
    T from_string(const std::string &s, size_t base)
    {
        assert((base > 1) && (base <= digits.length()));
        T number = T();
        for (auto c: s) {
            number *= base;
            size_t i = digits.find(c);
            assert(i < digits.length());
            number += i;
        }
        return number;
    }

}

int main()
{
    std::string   number_s = "LOL";
    unsigned long number   = 996308594307;
    size_t        base     = 36;

    std::cout << number << " = "
              << lol::to_string(number, base)
              << '_' << base << '\n';

    std::cout << number_s << '_' << base << " = "
                << lol::from_string<unsigned>(number_s, base)
                << '\n';
}

#1 xROAL
Nemam tip, cim by to mohlo byt, ale treba by pomohlo, kdyby se vystup te textovky delal v necem, co nejaky souradnicovy vystup na terminal umoznuje, napr. PDCurses (podle "cls" predpokladam, ze cilova "platforma" je windows).

#1 juruces

neco jako...

#include <string>
#include <iostream>

int main()
{
    std::string s;
    std::getline(std::cin, s);
    std::string::iterator i = s.begin(), j = s.end() - 1;
    for ( ; i != s.begin() + s.size() / 2; ++i, --j) *j = *i;
    std::cout << s << std::endl;
}

?

#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix_core.hpp>
#include <boost/spirit/include/phoenix_operator.hpp>
#include <boost/spirit/include/phoenix_stl.hpp>
#include <boost/fusion/include/boost_tuple.hpp>
#include <boost/lexical_cast.hpp>
#include <string>
#include <vector>
#include <stdexcept>

namespace qi = boost::spirit::qi;
using qi::grammar;
using qi::ascii::space_type;
using boost::variant;
using boost::tuple;
using boost::static_visitor;
using boost::apply_visitor;
using std::vector;
using std::string;
using std::cout;
using std::endl;
using std::runtime_error;

typedef variant<tuple<int,int>,int> year_entry;

template<typename Iterator>
struct year_parser : grammar<Iterator, year_entry(), space_type>
{
    year_parser() : year_parser::base_type(start)
    {
        using qi::int_;
        start %= (int_ >> '-' >> int_) | int_;
    }

    qi::rule<Iterator, year_entry(), space_type> start;
};

struct year_visitor : public static_visitor<vector<int>>
{
    vector<int> operator()(const tuple<int,int> &interval) const
    {
        if (interval.get<0>() > interval.get<1>())
            runtime_error("wtf the yearz are bad!");

        vector<int> years;
        for (int year = interval.get<0>();
                 year <= interval.get<1>();
               ++year) years.push_back(year);

        return years;
    }

    vector<int> operator()(int year) const
    {
        return vector<int>{year};
    }
};

int main()
{
    string years("2034-2040,1924-1926,2312,3452,1234-1236");
    vector<year_entry> years_vec;

    typedef string::const_iterator iterator;
    iterator i = years.begin();
    year_parser<iterator> parser;
    bool result = phrase_parse(i, years.cend(), parser % ',', qi::ascii::space, years_vec);

    if (!result) throw std::runtime_error("lol the string sucks!!!");

    vector<int> all_years;
    for (auto &entry : years_vec)
    {
        vector<int> vec = apply_visitor(year_visitor(), entry);
        all_years.insert(all_years.end(), vec.begin(), vec.end());
    }

    for (auto year : all_years) cout << year << " ";
    cout << endl;

    return 0;
}

#6 vitamin
jj to je pekna hlavolamka :)

Mimochodem, pouziti EXIT_SUCCESS a EXIT_FAILURE je nezavisle na platforme.

#3 Hanule
...Dynamická alokace mě nenapadla,...

To by mela, protoze v C kreace typu

int n;
scanf("%d", &n);
int mat[n][n];

dvojrozmerne pole n*n nealokuje.

 co treba...

char* join_two_fcking_strings(const char *s1, const char *s2)                                                          
{                                                                                                                       
    char *s = (char*)malloc(sizeof(char)*(strlen(s1)
                                         +strlen(s2)+1));        char *c = (char*)s1, *cc = s;                                                                                       
    for ( ; *c != 0; ++c, ++cc) *cc = *c;                    
    for (c = (char*)s2; *c != 0; ++c, ++cc) *cc = *c; 
    *cc = 0;                                                                                                            
    return s;                                                }          

#1 vitamin
pekne, kviz dokoncen vicemene ok... pokud by nekdo z mel pocit menecennosti, tak by snad radeji mel prestat v C++ programovat. podle me se nejedna ani moc o temna zakouti, jako o pomerne standardni veci. C++ holt neni pro kazdeho :)

#1 Hanule

1) Ani z popisu ulohy, ani z kodu neni jasne, co "to ma delat".

2) Tohle v C/C++ rozhodne nefunguje:

int n;
scanf("%d", &n);

int mat[n][n]; /* <---- neni mi jasne, co tohle ve skutecnosti dela, ale urcite ne to, co bylo pravdepodobne zamysleno */

Pro zacatek bych doporucil bud naucit se neco o dynamicke alokaci {jedno/vice}-rozmernych poli, pripade deklarovat matici s nejakym dostatecne velkym "N_max".