Salut! Cine propune subiectele pentru OJI?

Da, multumesc!

Salut! Ce parere aveti de urmatoarea problema:

Cod:

cout<<(int)'\0342'<<endl;

afiseaza 7218, in timp ce

Cod:

cout<<(int)(char)0342;

afiseaza -30 care mi se pare logic;

In primul rand 0342 = 226 in baza 10; Cum in char nu putem avea valori mai mari de 127 atunci ne confruntam cu o depasire care e tratata cilic de compilator datorita modificarii bitului de semn, adica -128 + 98 = -30;

Afla de cate ori se gasesc factorii primi 2, 5 si 10 printre factorii ce dau produsul! Fie numarul acestora n2, n5 si n10;
Atunci numarul de zerouri va fi min(n2,n5) + n10;

Salut!
Ce se intampla cu InfOnline anul acesta?! Mai sunt cateva zile pana la inceperea olimpiadei si inca nu s-a deschis site-ul! 

[sol[k][ b][f] = k daca sol[k-1][b-B[k]][f-F[k]] != 0 si sol[k-1][ b][f] daca este 0;]

Salut!

Problema : Problema Cazare

Nu stiu de ce nu merge! Depasesc si memoria si pic si teste! Daca nu gasiti problema pe codul meu, va rog sa imi lasati o idee de abordare, adica cum sa aplic metoda rucsacului ( in cazul in care nu am aplicat-o bine )!

Practic recurenta mea se bazeaza pe urmatoarea relatie:
sol[k][ b][f] = k daca sol[k-1][b-B[k]][f-F[k]] != 0 si sol[k-1][ b][f] daca este 0; In problema notatiile sunt altele, dar ideea este aceeasi!
Initial completez matricele sol[k][ b][f] = k, intr-un for.

Cod:

for(int i=1;i<=K;i++)
	{
		in>>clasa[i][0]>>clasa[i][1];
		for(int j=1;j<=i;j++)
			sol[i][clasa[j][0]][clasa[j][1]] = j;
	}

Cod:

#include <fstream>
#include <iostream>
#include <vector>
#include <memory>
#include <alloc.h>

#define bfMax 	1000
#define kMax 	101

#define fin 	"cazare.in"
#define fout 	"cazare.out"

using namespace std;

int B, F, K;
int clasa[kMax][2];

//bool sol[kMax][bfMax][bfMax];
//int  alege[kMax][bfMax][bfMax];
int ***sol;
//int ***alege;

void citeste()
{
	fstream in(fin, ios::in);
	in>>B>>F>>K;
	
	sol = (int***)malloc(sizeof(int**)*(K+1));
	//alege = (int***)malloc(sizeof(int**)*(K+1));
	for(int i=0;i<=K;i++)
	{
		sol[i] = (int**)malloc(sizeof(int*)*(B+1));
		//alege[i] = (int**)malloc(sizeof(int*)*(B+1));
		for(int j=0;j<=B;j++)
			sol[i][j] = (int*)malloc(sizeof(int)*(F+1)),
			//alege[i][j] = (int*)malloc(sizeof(int)*(F+1)),
			memset(sol[i][j], 0, sizeof(int)*(F+1));
			//memset(alege[i][j], 0, sizeof(int)*(F+1));
	}
	
	for(int i=1;i<=K;i++)
	{
		in>>clasa[i][0]>>clasa[i][1];
		for(int j=1;j<=i;j++)
			sol[i][clasa[j][0]][clasa[j][1]] = j;
	}
	in.close();
}

void solve()
{
	int w1, w2;
	
	for(int k=1;k<=K;k++)
	{
		for(int i=1;i<=B;i++)
			for(int j=1;j<=F;j++)
			{
				w1 = clasa[k][0];
				w2 = clasa[k][1];
				//sol[k][w1][w2] = k;
				//alege[k][w1][w2] = k;
				if(w1 <= i && w2 <= j)
				{
					if(sol[k-1][i-w1][j-w2] && !sol[k][i][j])
					{
						sol[k][i][j] = k;
						continue;
						//alege[k][i][j] = k;
					}
					else if(sol[k][i][j] == 0)
					{
						sol[k][i][j] = sol[k-1][i][j];
						continue;
						//alege[k][i][j] = alege[k-1][i][j];
					}
				}
				else if(sol[k][i][j] == 0)
				{
					sol[k][i][j] = sol[k-1][i][j];
					//alege[k][i][j] = alege[k-1][i][j];
				}
			}
			
		if(sol[k][B][F]>0)
		{
			K=k;
			break;
		}
	}
}

void tipar()
{
	int x=B, y=F, k=K, X;
	int object;
	
	vector<int> solution;
	
	while(sol[k][x][y])
	{
		object = sol[k][x][y];
		
		X = x;
 		solution.push_back(sol[k][x][y]);
 		x -= clasa[sol[k][x][y]][0];
		y -= clasa[sol[k][X][y]][1];
		k--;
		
		/*while(object == sol[k][x][y])
		{
			X = x;
			x -= clasa[sol[k][x][y]][0];
			y -= clasa[sol[k][X][y]][1];
			k--;
		}*/
	}
	
	fstream out(fout, ios::out);
	out<<solution.size()<<endl;
	for(int i=solution.size()-1;i>=0;i--) out<<solution[i]<<endl;
	
	/*for(int i=0;i<=K;i++)
	{
		out<<i<<":"<<endl;
		for(int j=0;j<=B;j++)
		{
			for(int k=0;k<=F;k++)
				out.width(2), out<<sol[i][j][k]<<" ";
			out<<endl;
		}
	}*/
	out.close();
}

void Drum(int k, int x, int y, ofstream &out)
{
	if(sol[k][x][y])
	{
		Drum(k-1, x-clasa[sol[k][x][y]][0], y-clasa[sol[k][x][y]][1], out);
		out<<sol[k][x][y]<<endl;
	}
}

int main(void)
{
	citeste();
	solve();
	//ofstream out(fout);
	//Drum(K, B, F, out);
	//out.close();
	tipar();
	
	/*for(int i=0;i<=K;i++)
	{
		for(int j=0;j<=B;j++)
			free(sol[i][j]);
			
		free(sol[i]);
	}
	
	free(sol);*/
	
	return 0;
}

Cod:

#include <iostream.h>
#include <string.h>

void main()
{
	char txt[256];
    cin.getline(txt, 256);

	int ok=1, len;
	char *p=strtok(txt, " ");
	while(p)
	{
		ok = 1;
		len = strlen(p);
		for(int i=0;i<len/2;i++)
			if(p[i] != p[len-i-1])
			{
				ok = 0;
				break;
			}
		if(ok) cout<<p<<endl;

		p=strtok(NULL, " ");
	}
}

Cod:

while(!feof(in))
{
   // instructiuni
}

Cu in am notat fisierul FILE *in = fopen("fisier.fmt", "mod");

LE: scuze nu am fost atent; pt freopen folosesti stdin in loc de in; Succes!

Nu trebuia sa pui while(!b)?
Incearca aici.

Da...
Oricum erau simple! Eu vreau sa fie cat mai multa practica ca la practica ma pricep!

Salut!:D
Din ce am citit pe site-ul ministerului am inteles ca bacul anul acesta va avea subiecte comune la informatica pt specializarile informatica-matematica si informatica-matematica intensiv! Este adevarat?
Ar fi cool! Erau nasoale alea de la simplu!

Salut!
Ce tipuri de probleme vor fi abordate?

Da stiu... asta! Dezvoltarile in serie Taylor! Numai ca nu eram sigur daca se foloseste aceasta metoda! Voiam sa stiu daca are aceeasi complexitate cu operatiile de *, / si de asta intrebam! In cazul in care se dezvolta in serie complexitatea e mai mare!
Ms de raspunsuri!

Salut! Ce algoritm foloseste c++ pentru extragerea radicalului (sqrt)? 

Pai da dar forul cu n este in interiorul forului cu k;

Cod:

int len = strlen(tr);
for(int l=1;l<len;l++)
{
	for(int i=0;i<len-l;i++)
	{
		res1[1] = '\0'; res2[1] = '\0';
		res1[0] = tr[i];
		strcat(res1, sol[0][i+1][i+l]);
		res2[0] = tr[i+l]; 
		strcat(res2, sol[0][i][i+l-1]);
		strcpy(sol[1][i][i+l], minimum(res1, res2));
			
		res1[1] = '\0'; res2[1] = '\0';
		res1[0] = tr[i];
		strcat(res1, sol[1][i+1][i+l]);
		res2[0] = tr[i+l]; 
		strcat(res2, sol[1][i][i+l-1]);
		strcpy(sol[0][i][i+l], maximum(res1, res2));
	}
}

LE: Am rezolvat! Am alocat matricea dinamic!

Cod:

void alocare()
{
	//sol = new char[2][nMax][nMax][nMax];
	int len = strlen(tr)+1;
	
	sol = new char***[2];
	for(int i=0;i<2;i++)
	{
		sol[i] = new char**[len];
		for(int j=0;j<len;j++)
		{
			sol[i][j] = new char*[len];
			/*for(int k=0;k<len;k++)
				sol[i][j][k] = new char[k],
				sol[i][j][k][1] = '\0';*/
		}
	}
	
	for(int i=0;i<len;i++)
	{
		for(int j=0;j<len-i;j++)
		{
			sol[0][j][j+i] = new char[i];
			sol[0][j][j+i][1] = '\0';
			
			sol[1][j][j+i] = new char[i];
			sol[1][j][j+i][1] = '\0';
		}
	}
}

Salut!
La problema RV (http://campion.edu.ro/arhiva/index.php?page=problem&action=view&id=100) am dedus urmatoarea recurenta:

Cod:

A[0][n-k][n] = min(s[n-k] + A[1][n-k+1][n], s[n] + A[1][n-k][n-1]);
A[1][n-k][n] = max(s[n-k] + A[0][n-k+1][n], s[n] + A[0][n-k][n-1]);

A[x][y][z] = sirul obtinut daca muta jucatorul x+1 cu sirul de la poz y la poz z pe tabla rosie!
s[n] = sirul aflat initial pe tabla rosie!

Recurentele functioneaza perfect, in offline obtin 100 de puncte, insa pe evaluatorul online depasesc spatiul de memorie!

Nu am incercat! Nu sunt sigur ca back-ul are viteza mai buna decat log-ul! Stiam ca logul are rezolvare liniara! Backul are exponentiala plus ca daca aplici varianta recursiva mai ingreuneaza si ea!

In primul rand imi pare a tema!
Ideea este destul de simpla. In niciun caz nu vei genera toate posibilitatile de 0 si 1, care se genereaza prin met BackTracking ci rezolvarea se bazeaza pe reprezentarea numerelor in baza 2! Nu este nevoie sa convertesti un numar in baza 2 pentru ca pc-ul a facut-o deja pentru tine!

Cod:

#include <math.h>

int nr0=0, nr1=0;
for(int i=0;i<n;i++)
{
    nr0=nr1=0;
    for(int j=0;j<(int)(log(i)/log(2))+1;j++)
        (i&(1<<j))?nr1++:nr0++;
    if(nr1 == nr0) cout<<i<<" ";
}

Sper sa mearga, nu am verificat! Succes!

Ms! Am gasit!
LE: Sincer... nu prea inteleg recurentele acelea! Daca esti bine-voitor sa mi le explici si mie..., ti-as ramane recunoscator , nici nu prea am avut timp suficient sa ma gandesc la ele!

Unde este implementarea lor? Acolo este numai ideea de rezolvare pe care nu o inteleg prea bine!

Salut! Vreau si eu o indicatie la problema aceasta! Nu am inteles prea bine indicatia lor, iar mie imi vin in cap tot felul de recurente pe care nu reusesc sa le implementez cum ar fi sa retin pentru fiecare pozitie a G-ului numarul de blocuri construibile cu k etaje! Daca ideea mea e buna..., atunci cum o implementez? Ms!

Link: http://campion.edu.ro/arhiva/index.php?page=problem&action=view&id=933

Ia-o pe incercate! Bagi la comentariu pe rand bucati din cod si compilezi! Prima data incepi cu tot codul, tot ce e in main, apoi scoti de la comentariu pe rand functii si instructiuni pana localizezi problema si apoi daca nu te descurci posteaza codul ce creaza problema aici!

Sal! Legat de algoritmica! A creea un algoritm semnificativ mai bun, inseamna a crea un algoritm cu o complexitate mai buna! Daca alg. are deja sa zicem complex n, ce ai mai putea face....! ; plus ca unii alg au fost demonstrati ca fiind deja optimi, deci prin urmare nu se poate da o solutie mai buna la problema respectiva, numai in cazul in care pica matematica!
Legat de programarea comerciala, depinde cu ce te ocupi in firma! Nu ai nevoie de multa algoritmica daca tu de exemplu creezi niste interfete cu VB si le populezi cu cod!

Si in final..... [...]

[editat de moderator] Nu se face "troc" cu asa ceva 

Nu este gresit while(1), deoarece urmeaza break;
LE: Da, codul cum era scris mai sus, nu avea niciun sens!

Salut!
Exista vreo metoda de a-ti verifica programul in timpul olimpiadei daca merge corect?
Se pot generea rapid teste..? sau exista o alta metoda?