3. Länge eines stringstreams, wie?

Länge eines stringstreams, wie?

  • T

    @ volkard:
    -200 * -1 = 200 = abs(-200)
    Mit Minuszahlen entsteht sonst eine Endlosschleife...

    Gruß

    0
  • U

    theliquidwave schrieb:

    Dein Code "failt" bei 0 (Länge = 0) und Minuszahlen (Endlosschleife).

    tur er nicht!?

    0
  • I

    theliquidwave schrieb:

    @ volkard:
    -200 * -1 = 200 = abs(-200)
    Mit Minuszahlen entsteht sonst eine Endlosschleife...

    Gruß

    Tatsächlich?

    -200 / 10 = -20
     / 10 = -2
     / 10 = 0
    0
  • V

    theliquidwave schrieb:

    @ volkard:
    -200 * -1 = 200 = abs(-200)
    Mit Minuszahlen entsteht sonst eine Endlosschleife...
    Gruß

    Ein Bißchen mehr Begründung hatte ich mir erträumt, denn bei mir gibt

    int i=-200;
	cout<<i<<' '<<get_length(i)<<'\n';

    brav

    -200 4

    aus.

    0
  • U

    wenn das minus in der länge mitzählen soll müsste die fkt so aussehen:

    int get_length(int value, bool count_minus = false)
{
  int ret_val = count_minus && value < 0;
  for(; value != 0; ++ret_val)
    value /= 10;
  return ret_val;
}

    bb

    0
  • V

    unskilled schrieb:

    wenn das minus in der länge mitzählen soll müsste die fkt so aussehen:

    int get_length(int value, bool count_minus = false)
{
  int ret_val = count_minus && value < 0;
  for(; value != 0; ++ret_val)
    value /= 10;
  return ret_val;
}

    bb

    Da wäre ich bei der 0 noch anderer Meinung.
    Deswegen bevorzuge ich do

    int get_length(int value, bool count_minus = false)
{
  int ret_val = count_minus && value < 0;
  do
    ++ret_val;
  while(value /= 10);
  return ret_val;
}
    0
  • U

    hmm... ich find do-while hässlich 😛
    war aber auch die ganze zeit davon ausgegangen, dass 0 die länge null haben sollte... mein fail : D

    int get_length(int value, bool count_minus = false)
{
  int ret_val( value == 0 || count_minus && value < 0 );
  for(; value != 0; ++ret_val)
    value /= 10;
  return ret_val;
}

    kein plan, ob das performance-mäßig was bringt, ich denke zwar schon, aber bin zu faul zu vergleichen... ^^

    bb

    0
  • S

    Hi,
    könnte man das Problem nicht einfacher lösen?
    Soweit ich mich erinnere kann man mit dem Logarithmus die Anzahl der stellen ermitteln...
    Man nehme entsprechend zum Zahlensystem einen Logarithmus und Rundet auf...
    Für das Dezimalsystem :

    int getLenght(int const& X)
{
    return log10( abs(X) ) +1 + (X<0);
}

    Gruss

    Edit:
    Man müsste noch testen bis zu welcher Zahl es sich lohnt, die schleifenversion zu nehmen und danach zu prüfen.

    0
  • U

    ich glaube kaum, dass es sich bei einer 32bit zahl überhaupt lohnen wird...

    alleine schon die ständigen umwandlungen wären für mich schon grund genug, es nicht zu verwenden...

    int g0(int const& X)
{
    return log10( abs(X) ) +1 + (X<0);
}

    kompiliert bei mir nicht mal (msvc9):
    error C2668: 'log10': Mehrdeutiger Aufruf einer überladenen Funktion

    ich hab mir mal erlaubt es so zu schreiben:

    #include <cmath>

unsigned int f(int X, bool count_minus = false)
{
	float log_10 = std::log10( float(abs(X)) );
	unsigned int ret_val = unsigned int(log_10);
	return ret_val + 1 + (count_minus && X<0);
}

    test-aufruf:

    unsigned int a = f(INT_MIN);
//a == 1

    der log-aufruf hier geht schief - in dem float steht irgend ein code, der sich mir nicht ganz erschließt - irgendwas mit IND001

    bb

    0
  • M

    theliquidwave schrieb:

    Dein Code "failt" bei 0 (Länge = 0) und Minuszahlen (Endlosschleife).
    Hier mal ein Fix 😉

    int get_length(int value)
{
	if (value == 0)
		return 1;
	
	int ret_val = 0;
	
	if (value < 0)
	{
		value *= -1;
		++ret_val;
	}
	
	for(; value != 0; ++ret_val)
		value /= 10;
	
	return ret_val;
}

    get_length(-2147483648);

    :p

    0
  • V

    Michael E. schrieb:

    theliquidwave schrieb:

    Dein Code "failt" bei 0 (Länge = 0) und Minuszahlen (Endlosschleife).
    Hier mal ein Fix 😉

    int get_length(int value)
{
	if (value == 0)
		return 1;
	
	int ret_val = 0;
	
	if (value < 0)
	{
		value *= -1;
		++ret_val;
	}
	
	for(; value != 0; ++ret_val)
		value /= 10;
	
	return ret_val;
}

    get_length(-2147483648);

    :p

    Das gibt aber auch kein falsches Ergebnis.
    Falls value*=-1 gar nicht benötigt wird, was zur Zeit vermutet wird.

    0
  • S

    unskilled schrieb:

    ich glaube kaum, dass es sich bei einer 32bit zahl überhaupt lohnen wird...

    alleine schon die ständigen umwandlungen wären für mich schon grund genug, es nicht zu verwenden...

    int g0(int const& X)
{
    return log10( abs(X) ) +1 + (X<0);
}

    Jo, hab das std:: vergessen, hinzukommt das ich X=0 nicht abfrage,
    lustigerweise funktionierte es bei mir trozdem (gcc), da ich es mit unsigned als Rückgabewert getestet habe und scheinbar -inf +1 zu null gecasted wird?!
    Ist das Compiler abhängig?
    Kann das jemand erklären?

    #include <iostream>
#include <cmath>

int main()
{
    std::cout << std::log10(0) <<"\n"; //-inf0
    std::cout << (int)std::log10(0)<<"\n"; // -2147483648
    std::cout << (unsigned int)std::log10(0); // 0
    return 0;
}
    0
  • T

    Was spricht gegen diese Lösung?

    unskilled schrieb:

    std::string get_int_as_string(int value)
{
  std::stringstream ss;
  ss << value;
  return ss.str();
}
    0
  • M

    Tachyon schrieb:

    Was spricht gegen diese Lösung?

    unskilled schrieb:

    std::string get_int_as_string(int value)
{
  std::stringstream ss;
  ss << value;
  return ss.str();
}

    Zu lahm.

    0
  • P

    Michael E. schrieb:

    Zu lahm.

    Wieviel lahmer? Zeitmessungen gemacht?

    0
  • M
     

    #include <iostream>
#include <string>
#include <sstream>
#include <boost/random/linear_congruential.hpp>
using namespace std;

typedef unsigned __int64 u64; 

#pragma warning(push) 
#pragma warning(disable:4035) 
u64 rdtsc() 
{ 
	__asm rdtsc; 
} 
#pragma warning(pop)

int getLength1(int arg)
{
	stringstream ss;
	ss << arg;
	return ss.str().length();
}

int getLength2(int arg)
{
	int ret = (arg < 0);

	do
		++ret;
	while(arg /= 10);

	return ret;
}

int main()
{
	const int n = 100000;
	int result[n];
	int (*func[2])(int) = { getLength1, getLength2};
	boost::rand48 generator;

	for(int i = 0; i < 10; ++i)
	{
		for(int j = 0; j < 2; ++j)
		{
			generator.seed(42);
			for(int k = 0; k < n; ++k)
				result[k] = generator();

			u64 start = rdtsc();

			for(int k = 0; k < n; ++k)
				result[k] = func[j](result[k]);

			u64 end = rdtsc();

			if(j)
				cout << end - start << "\n";
			else
				cout << end - start << " <-> ";
		}
	}
}

    Intel Core i3-330M, Windows 7 Home Premium 64 Bit, Visual Studio 2008 SP1, Optimierung auf "Geschwindigkeit maximieren":

    /O2 /Oi /GL /I "d:\boost/boost_1_42" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_UNICODE" /D "UNICODE" /FD /EHsc /MD /Gy /Fo"Release\\" /Fd"Release\vc90.pdb" /W3 /nologo /c /Zi /TP /errorReport:prompt

    Ausgabe:

    605812167 <-> 9224968
573697862 <-> 9301400
572169548 <-> 9157740
578836805 <-> 9419872
569198168 <-> 9235780
562688192 <-> 9165412
572129856 <-> 9244632
573213868 <-> 9171600
569073352 <-> 9297776
568769208 <-> 9402188

    Macht also einen Faktor von etwa 60.

    0
  • T

    Michael E. schrieb:

    [...]Zu lahm.

    Zu lahm wofür? Es geht nicht um das Ermitteln der Ziffernzahl. Es geht um das Erstellen eines Images des gegebenen Integers...

    0
  • P

    Michael E. schrieb:

    Macht also einen Faktor von etwa 60.

    Wenn die Funktion mit allen Aufrufen nur einen winzigen Bruchteil des Gesamtprogramms ausmacht macht ein Faktor 60 den Kohl auch nicht fett und reduziert die Auswahl zwischen den beiden Möglichkeiten zur Geschmackssache.

    0
  • U

    edit: oh - mein fehler : D

    0
  • F

    Da die Zahlen endlich sind, ist eine Lookup-Table doch schneller. 😃

    0
Anmelden zum Antworten