Teilen Sie eine Zahl durch 3, ohne * , / , + , - , % Operatoren zu verwenden

Question

Wie würden Sie eine Zahl durch 3 teilen, ohne die *, /, +, -, % Operatoren zu verwenden?

Die Zahl kann positiv oder negativ sein.

Answer 1

Wie wäre es mit diesem Ansatz (c#)?

private int dividedBy3(int n) {
        List a = new Object[n].ToList();
        List b = new List();
        while (a.Count > 2) {
            a.RemoveRange(0, 3);
            b.Add(new Object());
        }
        return b.Count;
    }

Answer 2

Lösung mit der fma() Bibliotheksfunktion, funktioniert für jede positive Zahl:

#include 
#include 

int main()
{
    int number = 8;//Irgendeine positive Zahl
    int temp = 3, result = 0;
    while(temp <= number){
        temp = fma(temp, 1, 3); //fma(a, b, c) ist eine Bibliotheksfunktion und gibt (a*b) + c zurück.
        result = fma(result, 1, 1);
    } 
    printf("\n\n%d durch 3 geteilt = %d\n", number, result);
}

Siehe meine andere Antwort.

Answer 3

Allgemein wäre eine Lösung dafür:

log(pow(exp(numerator),pow(denominator,-1)))

Answer 4

Verwenden Sie cblas, das als Teil des Accelerate-Frameworks von OS X enthalten ist.

[02:31:59] [william@relativity ~]$ cat div3.c
#import 
#import 

int main() {
    float Multiplikator = 123456.0;
    float Faktor = 0.333333;
    printf("%f * %f == ", Multiplikator, Faktor);
    cblas_sscal(1, Faktor, &Multiplikator, 1);
    printf("%f\n", Multiplikator);
}

[02:32:07] [william@relativity ~]$ clang div3.c -framework Accelerate -o div3 && ./div3
123456.000000 * 0.333333 == 41151.957031

Answer 5

Okay, ich denke, wir sind uns alle einig, dass dies kein reales Problem ist. Also nur zum Spaß, hier ist wie man es mit Ada und Multithreading macht:

with Ada.Text_IO;

procedure Divide_By_3 is

   protected type Divisor_Type is
      entry Poke;
      entry Finish;
   private
      entry Release;
      entry Stop_Emptying;
      Emptying : Boolean := False;
   end Divisor_Type;

   protected type Collector_Type is
      entry Poke;
      entry Finish;
   private
      Emptying : Boolean := False;
   end Collector_Type;

   task type Input is
   end Input;
   task type Output is
   end Output;

   protected body Divisor_Type is
      entry Poke when not Emptying and Stop_Emptying'Count = 0 is
      begin
         requeue Release;
      end Poke;
      entry Release when Release'Count >= 3 or Emptying is
         New_Output : access Output;
      begin
         if not Emptying then
            New_Output := new Output;
            Emptying := True;
            requeue Stop_Emptying;
         end if;
      end Release;
      entry Stop_Emptying when Release'Count = 0 is
      begin
         Emptying := False;
      end Stop_Emptying;
      entry Finish when Poke'Count = 0 and Release'Count < 3 is
      begin
         Emptying := True;
         requeue Stop_Emptying;
      end Finish;
   end Divisor_Type;

   protected body Collector_Type is
      entry Poke when Emptying is
      begin
         null;
      end Poke;
      entry Finish when True is
      begin
         Ada.Text_IO.Put_Line (Poke'Count'Img);
         Emptying := True;
      end Finish;
   end Collector_Type;

   Collector : Collector_Type;
   Divisor : Divisor_Type;

   task body Input is
   begin
      Divisor.Poke;
   end Input;

   task body Output is
   begin
      Collector.Poke;
   end Output;

   Cur_Input : access Input;

   -- Eingabewert:
   Number : Integer := 18;
begin
   for I in 1 .. Number loop
      Cur_Input := new Input;
   end loop;
   Divisor.Finish;
   Collector.Finish;
end Divide_By_3;