Trocha rekurze nemůže škodit

10.11.2008 21:52 | Přečteno: 1830× | Ostatní | poslední úprava: 10.11.2008 21:54

Jen tak, před nedávnem, z dlouhé chvíle vzniklo toliko kódu…

#include "iostream"
using namespace std;

class CsSuccesor
{
public:
	CsSuccesor();
	CsSuccesor(CsSuccesor &that);
	~CsSuccesor();
	CsSuccesor& Succesor(CsSuccesor &that);
	friend ostream& operator <<(ostream &stream, CsSuccesor succesor);
	CsSuccesor& operator =(CsSuccesor &that);
	CsSuccesor& operator +(CsSuccesor &that);
	CsSuccesor& operator -(CsSuccesor &that);
	unsigned long long int ToInteger();

private:
	CsSuccesor *m_pSucc;
};

CsSuccesor::CsSuccesor()
{
	m_pSucc = NULL;
}

CsSuccesor::CsSuccesor(CsSuccesor &that)
{
	m_pSucc = NULL;

	if (that.m_pSucc != NULL)
	{
		m_pSucc = new CsSuccesor(*(that.m_pSucc));
	}
}

CsSuccesor::~CsSuccesor()
{
	if (m_pSucc != NULL)
	{
		delete m_pSucc;
		m_pSucc = NULL;
	}
}

CsSuccesor& CsSuccesor::Succesor(CsSuccesor &that)
{
	m_pSucc = new CsSuccesor();
	if (that.m_pSucc != NULL)
	{
		m_pSucc->Succesor(*(that.m_pSucc));
	}
	return *this;
}

ostream& operator <<(ostream &stream, CsSuccesor succesor)
{
	if (succesor.m_pSucc)
	{
		stream << "Succ(" << *(succesor.m_pSucc) << ")";
	}
	else
	{
		stream << "Zero";
	}
	return stream;
}

CsSuccesor& CsSuccesor::operator =(CsSuccesor &that)
{
	if (this != &that)
	{
		if (m_pSucc != NULL)
		{
			delete m_pSucc;
			m_pSucc = NULL;
		}
		if (that.m_pSucc)
		{
			m_pSucc = new CsSuccesor(*that.m_pSucc);
		}
	}
	return *this;
}

CsSuccesor& CsSuccesor::operator +(CsSuccesor& that)
{
	CsSuccesor* out = new CsSuccesor();
	if (m_pSucc != NULL)
	{
		out->m_pSucc = new CsSuccesor(*m_pSucc + that);
	}
	else
	{
		if (that.m_pSucc != NULL)
		{
			out = new CsSuccesor(that);
		}
	}
	return *out;
}

CsSuccesor& CsSuccesor::operator -(CsSuccesor& that)
{
	CsSuccesor* out = new CsSuccesor(*this);
	if (that.m_pSucc != NULL)
	{
		if (m_pSucc != NULL)
		{
			delete out;
			out = new CsSuccesor(*m_pSucc - *that.m_pSucc);
		}
	}
	return *out;
}

unsigned long long int CsSuccesor::ToInteger()
{
	return (m_pSucc != NULL ? m_pSucc->ToInteger() + 1 : 0);
}

int main()
{
	CsSuccesor succ1;
	cout << succ1 << '\n' << succ1.ToInteger() << '\n';
	CsSuccesor succ2(succ1);
	cout << succ2 << '\n' << succ2.ToInteger() << '\n';
	CsSuccesor succ3(succ1.Succesor(succ2));
	cout << succ3 << '\n' << succ3.ToInteger() << '\n';
	CsSuccesor succ4 = succ3;
	cout << succ4 << '\n' << succ4.ToInteger() << '\n';
	CsSuccesor succ5 = succ3 + succ4;
	cout << succ5 << '\n' << succ5.ToInteger() << '\n';
	CsSuccesor succ6 = succ5 - succ3;
	cout << succ6 << '\n' << succ6.ToInteger() << '\n';

	return 0;
}

…netvrdím, že ve všech rysech je to dokonalé, ale zábavné a hravé.

       

Komentáře

[dum8d0g]

to se tak strasne bojis komentaru? to ti proboha udelali..

[dum8d0g]

*co

[vogo]

tohle je tzv. „no comment code“ :)

u vážně míněného kódu komentáře píšu

[Heron]

Tak tady jsou tak krátké metody (což je jedině dobře), že jejich fce je tak plně popsána jejich jménem (tak to má být).

Pravda, mohlo být popsáno API, ale jako kód pro radost se mi to na první pohled líbí (chyby jsem nehledal).

[zde]

Proč? Navzdory neskutečně ukecanému a silně uhozenému programovacímu jazyku je to docela čitelné. BTW takhle se obvykle v teorii čísel formálně definují přirozená čísla- je to prostě nejjednodušší.

[vogo]

Přesně o to jde, je to rekurzívní datový typ celé číslo. Zřejmě kolega :).

[Ignor]

V teorii čísel asi ne, tam to je spíš nanic.

Jestli jsem to dobře pochopil (za což fakt neručím), tak to připomíná ňákou takovouhle konstrukci třeba

0 = {}; S(n) = {n}

než tu běžnou z teorie množin

0 = {}; S(n) = n u {n}

[kralyk z abclinuxu]

Už nevim, kdo to řekl, ale:

"Real Programmers don't use comments. If it was hard to write, it should be hard to read."

[Jirka]

To už by to mohlo vypadat rovnou takhle:

void do(int A[], int s) { int i, j, k, l; k = size / 2; while (k > 0) { for (i = k; i < s; i++) { j = i; l = A[i]; while ((j >= k) && (A[j-k] > l)) { A[j] = A[j - k]; j = j - k; } A[j] = l; } if (k == 2) k = 1; else k = (int) (k / 2.2); } }

Eliminace poznámek a (tím blbým způsobem jsou i vhodné názvy proměnných formou poznámek a přesto znám programátory, kteří používají jména jako: xx, yy, xxx, yyy, xxxx, yyyy) substituce názvů proměnných jejich stručnějším ekvivalentem, zde imho naprosto znečitelnila tento (jinak profláklý) kus kódu.

Ono to zcela jistě bylo myšleno jako ironie, ale někdo by se té citace mohl chytnout.

(Přebráno s mírnou úpravou z wikipedie.)

[Jirka]

Omlouvám se, nějak jsem při náhledu ignoroval špatný tag:

void do(int A[], int s) 
{ 
  int i, j, k, l; 
  k = size / 2; 

  while (k > 0) 
  { 
    for (i = k; i < s; i++) 
    { 
      j = i; 
      l = A[i]; 
      
      while ((j >= k) && (A[j-k] > l)) 
      { 
        A[j] = A[j - k]; 
        j = j - k; 
      } 
    
      A[j] = l; 
    } 

    if (k == 2) k = 1; else k = (int) (k / 2.2); 
  } 
} 

[Michal Kubeček]

Já myslel, že to byl záměr… :-)

[Jirka]

Myslím, že odsazují i ti největší barbaři (kromě soutěží v zatemňování kódu).

[Michal Kubeček]

A také kromě těch, kdo se s programovacím jazykem utkávají jen proto, že kvůli zápočtu/zkoušce musejí. Viděl jsem i jedince, kteří sice odsazovali (nejspíš proto, že jim řekli, že se to má), ale víceméně nahodile, bez vazby na strukturu zdrojáku.

[xavier]

Nebo tak.

[hikikomori82]

A teraz verzia pre bash, asi 100x jednoduchsia

#!/bin/bash
echo "Nejaky text"
echo "Nejaky text"
echo "Nejaky text"
echo "Nejaky text"
echo "Nejaky text"
echo "Nejaky text"

[Kverulant]

nevidim rekurziu

[hikikomori82]

Naco, na vypis piatich textov potrebujete rekurziu a 100 riadkov kodu?

[Michal Kubeček]

Třeba na to, aby titulek dával smysl. :-)

[:::]

CsSuccesor& CsSuccesor::operator -(CsSuccesor& that)
{
	CsSuccesor* out = new CsSuccesor(*this);
	if (that.m_pSucc != NULL)
	{
		if (m_pSucc != NULL)
		{
			delete out;
			out = new CsSuccesor(*m_pSucc - *that.m_pSucc);
		}
	}
	return *out;
}

tak se mi udelalo nevolno a ted jdu uz radsi spat... jen tak na okraj - pan je Javista ???

[vogo]

bývalý…

mínus jsem chtěl předělat, ale pak jsem na to zapomněl :)

[JS]

Chtel jsem vas upozornit na zajimavy clanek:

Trocha rekurze nemůže škodit

[skonciljsem]

Tenhle je taky prima.

[Kverulant]

Ja som niekde videl odkaz na dobry odkaz.

[mkoubik]

Tenhle je lepší.

[Václav "Darm" Novák]

Dík, mrknu se.

[:::]

super, ale chybi ti tam podminka na ukonceni rekruze...

[JS]

Nechybi, ta je tam implicitni - po urcite dobe bude prislusny proces automaticky ukoncen operacnim systemem.

[Kverulant]

Nechybi, ta je tam implicitni - po urcite dobe bude prislusny proces automaticky ukoncen operacnim systemem.

Alebo ujom z elektrarni Elektrikari su naj hackeri Vypnu a je to...

[kralyk z abclinuxu]

Naprosto nejlepší vysvětlení rekurze je tady.

[Michal Fecko]

Pamatam sa ako na strednej nas informatikarka ucila triedenie s pouzitim rekurzie a vzdy to komentovala takto: "Vnarame sa, vnarame sa, vnarame sa, HOP a už sa vynárame, a znova sa vynárame ... "

[rtfm]

lisp? haskell? -> pleasure

[vogo]

haskel