Nächste Vielfache von 8 ohne Kontrollstruktur berechnen?



  • Hab ne Frage. Ist es möglich das vielfache von 8 einer Zahl zu berechnen ohne eine Kontrollstruktur zu verwenden. So hab ich es bis jetzt aber es ist ein if dabei 😡

    void main(void)
    {
    	int Zahl;
    	cout << "Gib eine Zahl ein: ";
    	cin  >> Zahl;
    
    	int x = (Zahl/8)*8;
    	if(x<Zahl)
    		x+=8;
    
    	cout << x;
    }
    

    Danke im Voraus



  • (x+7) % 8



  • Danke Bashar
    Deine Antwort war zwar kurz aber hilfreich 😉
    MFG SpaceMonkey



  • ... allerdings leider völlig falsch. Freut mich, dass es dir trotzdem geholfen hat *g*



  • dein (x+7)%8 hat mir aber trotzdem geholfen. so habe ich durch deine Hilfe folgendes zusammengebastelt:

    int Zahl;
    
    	cout << "Gib eine Zahl ein: ";
    	cin  >> Zahl;
    
    	int x=((Zahl+7)%8);
    	int y=x+4;//So wird y 11 eine Primzahl wenn die eingegebene Zahl 
                        //durch 8 teilbar
    	y=y%10%9%8%7%6%5%4;//alles auf 0 setzen außer wenn Zahl 
                   //durch 8 teilbar auf 1
    	int NaechsteVielfache=(Zahl/8)*8 + 8-8*y;
    	//8 von NaechsteVielfache abziehen wenn Zahl durch 8 teilbar
    
    	cout << "Das naechste Vielfache ist "<<NaechsteVielfache;
    

    Also nochmals Danke 🙂



  • y=y%10%9%8%7%6%5%4;
    

    😮 😮

    int x = ((Zahl+7)/8)*8;
    

    Oder hab ich da was übersehen?



  • Versteh dich nicht!



  • int x = (Zahl+7) - (Zahl+7)%8;
    //oder
    int x = ((Zahl+7)/8)*8;
    

    Berechnen beide das nächstgrößere Vielfache von 8 (das war doch das Problem, oder sehe ich das falsch?)



  • So gehts natürlich auch 👍 hab anfangs nicht verstanden was du willst



  • y=y%10%9%8%7%6%5%4;
    

    😮 😮

    Das sollte nur mein ungläubiges Staunen über diese sehr interessante Formel zum Ausdruck bringen 😉



  • Deine Formel ist zwar kürzer als meine, meine verteht man aber dafür nicht gleich! 😃



  • Das stimmt, ist manchmal durchaus von Vorteil 😃
    👍



  • #include <stdio.h>
    
    int main()
    {
      int i;
      scanf("%d",&i);
      printf("%d\n",i+7&~0x7);
      return 0;
    }
    

    😃



  • Was machst du da? 😮

    i+7&~0x7
    


  • ~0x7 ist die Invertierung des Hex/Oktalwertes 7, gedacht als Bitmaske, sieht also dann so aus 1111...11000.
    Durch das & werden die letzten drei Bits von i+7 genullt, was einer Rückstellung auf die letzte durch 8 teilbare Zahl gleichkommt (denn der Restanteil +1...+7 wird damit weggefiltert). Im Zusammenhang mit dem von allen verwendeten +7 (um über jene nächste Grenze zu hüpfen), ergibt es genau den erwünschten Effekt. Lässt sich auf alle Potenzen von 2 anwenden - streng genommen nur im unsigned-Bereich, aber wir hatten Kontrollstrukturen ja ausgeschlossen 😛
    Mit den günstigen Operatorhierarchien ging es ohne Klammern in diesem Fall, sieht hübsch aus und erschreckt Newbies 🙂

    Ich gehe sogar davon aus, dass Eure Aufgabensteller mit dieser Frage diejenigen finden wollte, die schon ein richtiges Gefühl für die Bits entwickelt haben, dann ist es nämlich diese Lösung. Sicherlich sind die Modulo-Dinge richtig und angebracht - aber für den Fall 8 (oder eben anderer Zweierpotenzen) gibt es noch diese spezielle Lösung.
    Ich kann sogar noch eine auf dieser Basis anbieten:

    #include <stdio.h> 
    
    int main() 
    { 
      int i; 
      scanf("%d",&i); 
      printf("%d\n", ((i+7)>>3)<<3);
      return 0; 
    }
    

    hier ersetzt der Shift die Division und Multiplikation mit 8.



  • Sehr interessant was du da mit den Bits anstellst. 😮
    Wie kommst du darauf dass du zuerst invertieren, dann die letzen drei bits auf null stellen musst... Wie weißt du wann du was anwenden mußt? Und was bringen dir diese bitoperationen? Ich glaube nicht dass dir das ne Menge Geschwindigket spart. Und was würde es noch für Bitoperationen geben 😕



  • ...das kommt mit der Zeit.
    Schau Dir mal einfach sämtliche Operatoren an.
    Es spart Zeit, wenn Du wirklich rechenintensive Sachen machst.
    Es kann aber durchaus sein, dass ein sehr gut optimierender Compiler Dinge wie *8 sowieso in <<3 umsetzt.



  • Dazu braucht es keinen sehr gut optimierenden Compiler, diese Optimierung ist trivial 🙂 Das können Compiler schon lange.



  • besser gesagt solche Bitoperationen braucht es gar nicht?



  • Doch, aber nicht *8 zu ersetzen.


Log in to reply