Dezimal Ziffern Anzahl herausbekommen [Performatanteste Methode]



  • Hmm also hab bsw ne Zahl 10123 ... dann soll die Funktion mir 5 zurück geben ... müsste ja eigentlich noch ne bessere Version als folgendes geben:

    template <class t>
    std::size_t digit_count(const t& num)
    {
    	std::ostringstream ss;
    	ss << num;
    	return (!ss ? 1 : ss.str().length());
    }
    

    ... jemand nen Vorschlag?



  • Teile ganzzahlig durch 10, bis 0 rauskommt.
    Oder berechne direkt den 10er-Logarithmus, gerundet natürlich.



  • Ist die Frage ob das schneller ist ...



  • std::size_t digit_count(const std::size_t& num)
    {
    	if (num == 0)
    		return 1;
    
    	std::size_t num_tmp = num;
    	std::size_t dig = 0;
    	for (; num_tmp > 0; ++dig, num_tmp /= 10);
    	return dig;
    }
    

    geht ja auch ... aber die Frage ist ganz einfach was das schnellste ist!



  • (D)Evil schrieb:

    […] geht ja auch ... aber die Frage ist ganz einfach was das schnellste ist!

    Teste doch. 😉

    Na ja, ich würde aber trotzdem sagen, dass die arithmetische Variante schneller ist, denn bei der anderen fällt die ganze Stream-Speicherverwaltung an.

    /EDIT: PS: Ich hätt's natürlich rekursiv implementiert. :-p



  • (D)Evil schrieb:

    ... aber die Frage ist ganz einfach was das schnellste ist!

    warum habt Ihr's eigentlich alle so eilig? 😉

    Wenn man sich auf positive int-Variablen beschränkt (bei 4Byte pro int) vielleicht diese furchtbar unflexible Variante:

    std::size_t digit_count( int x )
    {
        if( x < 100000 )
        {
            if( x < 100 )
                return x < 10? 1: 2;
            else
                return x < 10000? ( x < 1000? 3: 4 ): 5;
        }
        else
        {
            if( x < 10000000 )
                return x < 1000000? 6: 7;
            else
                return x < 100000000? 8 : ( x < 1000000000? 9: 10 );
        }
    }
    

    Gruß
    Werner



  • Keine Ahnung, wie das im Vergleich abschneidet, aber ich hätte da auch noch einen Ansatz :D:

    size_t digit_count(int x)
    {
      int vals[] = {10,100,1000,10000/*...*/},v_len=sizeof(vals)/sizeof(int);
      int* pos = upper_bound(vals,vals+vlen,x);
      return pos-vals+1;
    }
    


  • Werner Salomon schrieb:

    Wenn man sich auf positive int-Variablen beschränkt

    x = abs(x); zu unperformant?


Anmelden zum Antworten