Minus, Plus, Zeiten, Potenzierung?

26

Dies ist eine CMC (Chat Mini Challenge), die ich vor einiger Zeit in unserem Chatraum The Ninteenth Byte gepostet habe.

Die Herausforderung

Gehen Sie bei einer positiven Ganzzahl xin Abhängigkeit von den letzten 2 Bits von xwie folgt vor:

x & 3 == 0: 0
x & 3 == 1: x + x
x & 3 == 2: x * x
x & 3 == 3: x ^ x (exponentiation)

Input-Output

Single Integer -> Single Integer

In der Ausgabe ist ein abschließender Zeilenumbruch zulässig. Kein anderes Leerzeichen ist zulässig.

Testfälle

input       output
    1            2
    2            4
    3           27
    4            0
    5           10
    6           36
    7       823543
    8            0
    9           18
   10          100
   11 285311670611
   12            0

Dies ist eine Code-Golf- Herausforderung, also gewinnt der kürzeste Code!

code-golf  math 
— HyperNeutrino
quelle
8
Sollte es nicht so 0sein x + 2, wie es den anderen x * 2geht x ^ 2, und x ^^ 2(Tetration)? : P
— ETHproductions
Was ist der größte Output, den wir unterstützen sollten (in Bezug auf x ^ x)? 32-Bit reicht für Testfälle bereits nicht aus 11und 64-Bit reicht für Testfälle nicht aus 19.
— Kevin Cruijssen
@ KevinCruijssen Ich werde sagen, dass Sie nur Fälle behandeln müssen, in denen die Eingabe und Ausgabe im Bereich Ihrer Sprache liegen, solange Ihr Programm theoretisch bei einer unendlichen Zahl funktionieren würde.
— HyperNeutrino
@HyperNeutrino Ok, in diesem Fall habe ich meinen (Java 7) Code (für +72 Bytes .. xD)
— korrigiert

Antworten:

13

Gelee , 8 Bytes

ị“+×*_”v

Probieren Sie es online!

Wie es funktioniert

Beachten Sie zunächst, dass x&3entspricht x%4, wo %Modulo ist. Da Jelly dann modular indexing ( a[n] == a[n+len(a)]) verwendet, müssen wir uns damit nicht einmal befassen.

Dann:

  • If x%4==0, return x_x(Subtraktion) (aus Konsistenzgründen);
  • Wenn x%4==1, kehre zurück x+x;
  • If x%4==2, return x×x(Multiplikation);
  • If x%4==3, return x*x(Potenzierung)

Beachten Sie, dass Jelly die 1-Indexierung verwendet, sodass die Subtraktion "_"an das Ende verschoben wird.

ị“+×*_”v  example input: 10
ị“+×*_”   index 10 of the string “+×*_”, which gives "×"
       v  evaluate the above as a Jelly expression,
          with 10 as the argument, meaning "10×" is the
          expression evaluated. The dyad "×" takes the
          second argument from the only argument, effectively
          performing the function to itself.
— Undichte Nonne
quelle
2
@andrybak AFAIK Jelly hat eine eigene Codierung - siehe hier , aber ich weiß, dass alle seine Zeichen 1 Byte sind.
— Stephen
"8 Bytes". Wie sollen Bytes gezählt werden? Diese Antwort besteht aus acht Zeichen, aber mindestens in der Codierung stackexchange dient diese Seite, es dauert 15 Bytes (gezählt mit wc --bytes).
— Andrybak
Wenn die Sprache es in einer Codierung interpretiert, ist es nicht sinnvoll, eine andere Codierung für die Bytezahl (imo) zu verwenden
— Mackenzie McClane
@andrybak Der in einer Codierung codierte Code, der vom Browser korrekt angezeigt wird, ist 15 Byte. Der Code in einer Codierung, die Jelly versteht, ist 8 Byte. Schauen Sie unter github.com/DennisMitchell/jelly/wiki/Code-page nach, wenn Sie wissen möchten, wie es codiert ist.
— Etoplay
9

CJam , 12 Bytes

ri__"-+*#"=~

Probieren Sie es online!

Erläuterung

ri            e# Read an int from input (call it x).
  __          e# Duplicate x twice.
    "-+*#"    e# Push this string.
          =   e# Get the character from the string at index x (mod 4).
           ~  e# Eval that char, using the two copies of x from before.

Führt je nach xdem Wert von mod 4 eine der folgenden Operationen aus (mod 4 entspricht AND 3).

0:  -  Subtraction
1:  +  Addition
2:  *  Multiplication
3:  #  Exponentiation
— Geschäfts-Katze
quelle
6

Mathematica 25 Bytes

0[2#,#*#,#^#][[#~Mod~4]]&

4 Bytes gespart dank @MartinEnder

— Kelly Lowder
quelle
4

Pyth, 8 Bytes

.v@"0y*^

Dolmetscher

— Erik der Outgolfer
quelle
Ja, ich habe das getestet und es funktioniert. Und nein, ich kann nicht vanstelle von verwenden .v.
— Erik der Outgolfer
Ich dachte, der Bereich sei lokal ... Ich dachte, ich .vkann nicht darauf zugreifen Q... Anscheinend habe ich mich in Pyth geärgert. +1 für dich.
— Undichte Nonne
@LeakyNun Nein, es ist das, vwas lokalen Geltungsbereich hat, .vnur einen Ausdruck auswertet.
— Erik der Outgolfer
Ich muss noch viel lernen ...
— Undichte Nonne
3
Das ist schön! Das ist absolut erstaunlich! Ich hatte keine Ahnung, dass das überhaupt möglich war. Für Stilpunkte "0y*^könnte das sein "-+*^.
— isaacg
3

Haskell, 28 27 Bytes

f x=cycle[0,x+x,x*x,x^x]!!x

Probieren Sie es online!

Edit: Danke an @ Ørjan Johansen für 1 Byte.

— nimi
quelle
Hm, ich bin sehr spät dran, aber du könntest das mit einem Byte verkürzen cycle.
— Ørjan Johansen
@ ØrjanJohansen: Besser spät als nie. Vielen Dank!
— nimi
2

C, 63 oder 62 Bytes

#include<math.h>
f(x){return(int[]){0,x+x,x*x,pow(x,x)}[x&3];}

-1 Byte, wenn Makros erlaubt sind, vorausgesetzt, es xhandelt sich nicht um einen Ausdruck wie 3+5(da dies den Vorrang verfälschen würde):

#include<math.h>
#define f(x)(int[]){0,x+x,x*x,pow(x,x)}[x&3]
— Tim Čas
quelle
@ceilingcat Richtig, vergessen.
— Tim Čas
Kompiliert nicht unter MSVS2015. Intellisense sagte cast to incomplete array type "int[]" is not allowedCompiler sagte error C4576: a parenthesized type followed by an initializer list is a non-standard explicit type conversion syntax; EBENFALLS! wo ist int f (int x)? Code ist tatsächlich mindestens 8 Byte länger; es ist auch sehr langsam und ineffizient, da es alles auswertet - nicht wiederholen IRL)
@ xakepp35 Was? 1) Es muss in einem C-Compiler kompiliert werden. Die meisten C-Compiler (mit Ausnahme von MSVC) unterstützen diese (int[])Syntax für diese Situation. 2) f(x)ist völlig legal C89. Ich habe den Standard nicht angegeben. 3) Hier geht es um die Codegröße, nicht um die Effizienz. Und 4) Wenn Sie bevormunden, verwenden Sie mindestens einen echten Compiler und / oder überprüfen Sie Ihre Fakten.
— Tim Čas
@ Tim Cas Ah ja, tut mir leid! Ich habe versucht, es als C ++ - Code zu kompilieren. Das ist meine Schuld) Es kompiliert und funktioniert super!
2

Java 7, 75 Bytes

long c(int n){int x=n%4;return x<1?0:x<2?n+n:x<3?n*n:(long)Math.pow(n,n);}

Obwohl es nach den Regeln gültig longist, 64-Bit ist, schlägt es für die Exponentiationstestfälle von 19^19und darüber fehl . Um das zu beheben, können wir einen BigDecimalAnsatz verwenden:

148 146 Bytes

import java.math.*;BigDecimal c(int n){int x=n%4;BigDecimal m=new BigDecimal(n);return x<1?m.subtract(m):x<2?m.add(m):x<3?m.multiply(m):m.pow(n);}

Erklärung (des BigDecimal-Ansatzes):

import java.math.*;                // Import required for BigDecimal
BigDecimal c(int n){               // Method with integer parameter and BigDecimal return-type
  int x=n%4;                       //  Input modulo-4
  BigDecimal m=new BigDecimal(n);  //  Convert input integer to BigDecimal
  return x<1?                      //  If the input mod-4 is 0:
    m.subtract(m)                  //   Return input - input (shorter than BigDecimal.ZERO)
   :x<2?                           //  Else if the input mod-4 is 1:
    m.add(m)                       //   Return input + input
   :x<3?                           //  Else if the input mod-4 is 2:
    m.multiply(m)                  //   Return input * input
   :                               //  Else:
    m.pow(n);                      //   Return input ^ input
}                                  // End of method

Testcode:

Probieren Sie es hier aus.

import java.math.*;
class M{
  static BigDecimal c(int n){int x=n%4;BigDecimal m=new BigDecimal(n);return x<1?m.subtract(m):x<2?m.add(m):x<3?m.multiply(m):m.pow(n);}

  public static void main(String[] a){
    for (int i = 1; i <= 25; i++) {
      System.out.print(c(i) + "; ");
    }
  }
}

Ausgabe:

2; 4; 27; 0; 10; 36; 823543; 0; 18; 100; 285311670611; 0; 26; 196; 437893890380859375; 0; 34; 324; 1978419655660313589123979; 0; 42; 484; 20880467999847912034355032910567; 0; 50;
— Kevin Cruijssen
quelle
Sie müssen das Programm nicht folgendermaßen reparieren: P Die alte Antwort würde funktionieren, wenn die Anzahl unendlich groß wäre. Das erste Programm wäre nach meinen Angaben gültig gewesen. : P
— HyperNeutrino
@HyperNeutrino Dann gebe ich das in der Antwort an. Na ja, Java wird sowieso keine Code-Golf-Herausforderungen gewinnen. ;)
— Kevin Cruijssen
1
Ja, würde ich angeben. Und ja, es ist Java, es wird nicht gewinnen. : D
— HyperNeutrino
2
" Und ja, es ist Java, es wird nicht gewinnen.: D " Ich bin daran gewöhnt. : P Selbst meine kürzeste Java-Antwort von je 8 Bytes ist im Vergleich zu den Golf-Antworten viel zu lang. xD Obwohl es das erste Mal war, dass ich mit meiner Java-Antwort eine Python-Antwort geschlagen habe, muss das für etwas zählen, was ich denke. ;)
— Kevin Cruijssen
2

x86-Assembler, Intel-Syntax, 192 Byte

.data
f dw @q,@w,@e,@r
.code
mov ecx, eax
and ecx, 3
mov edx,dword ptr f[ecx*4]
call [edx]
ret
q:
xor eax,eax
ret
w:
add eax,eax
ret
e:
mul eax,eax
ret
r:
mov ecx,eax
t:
mul eax,eax
loop t
ret

Beispiel gibt vor, die schnellste Arbeitsgeschwindigkeit zu haben. Is ist ein Programm oder Programmteil, das die Fastcall-Konvention verwendet. Es nimmt die Eingangsvariable xin register eaxan und gibt das Ergebnis auch in zurückeax . Die Grundidee ist, keine bedingten Sprünge zu verwenden, wie in einigen Beispielen hier. Es ist auch nicht alles auszuwerten (wie in C-Beispiel mit Arrays), sondern ein Array von Zeigern zu Funktionen zu verwenden und schnellere bedingungslose Sprünge (jmp / call) als optimiertes "C language switch () - case .." - Analog. Diese Technik kann auch in Finita-Automaten wie Prozessoremulatoren, Executoren usw. nützlich sein.

Upd: Verwenden Sie für x64 "r" in Registernamen anstelle von "e" (z. B. raxanstelle von eax, rcxanstelle von ecx). Die Größe wird nicht geändert und es werden 64-Bit-Wörter ohne Vorzeichen verwendet.

Willkommen bei PPCG! Ziel dieser Herausforderung ist es, Ihren Code so kurz wie möglich zu halten. In diesem Fall kann Ihr Code durch die Kombination all dieser Funktionsdeklarationen leicht um ein Vielfaches verkürzt werden. Sie können auch Leerzeichen entfernen.
— HyperNeutrino
@HyperNeutrino asm selbst ist ein bisschen "lang" Sprache :) also habe ich keine Ahnung, wie man das kürzer macht. irgendwelche beispiel-ratschläge?
Tut mir leid, ich muss meinen Kommentar zu Ihrer C-Antwort in diesen Beitrag kopiert haben. Ich weiß nicht, wie man in ASM programmiert, aber könnten Sie möglicherweise etwas Leerzeichen entfernen?
— HyperNeutrino
@HyperNeutrino, sorry .. aber anscheinend nein) es muss unter anderem der längste Code sein, ich kann nur Windows CRLF auf Linux-Format kürzen, so dass 209-> 192 Bytes, Änderungen sind nicht sichtbar)
Aw. Das ist sehr schade. Trotzdem nette Vorlage! :)
— HyperNeutrino
2

C #, 39 Bytes

x=>new[]{0,2,x,Math.Pow(x,x-1)}[x&3]*x;

Erläuterung

Beachten Sie, dass:

(xx, x + x, x * x, x ^ x) == (0, 2, x, x ^ (x-1)) * x

Die Lösung erstellt ein Array, indiziert es und multipliziert das Ergebnis mit x:

x => new[] { 0, 2, x, Math.Pow(x,x-1) }[x&3] * x;

Alternative Versionen:

x=>new[]{0,x+x,x*x,Math.Pow(x,x)}[x%4];

(39B, alle im Array durchgeführten Multiplikationen x%4ersetzen x&3)

x=>x%4<2?x%2*2*x:Math.Pow(x,x%4<3?2:x);

(39B, wie bei @ MetaColon, jedoch x%2*2*xersetzt x*x%4<1?0:2)

— user1655772
quelle
1

Eigentlich 12 Bytes

;;3&"-+*ⁿ"Eƒ

Probieren Sie es online!

Erläuterung:

;;3&"-+*ⁿ"Eƒ
;;            two copies of input (so 3 total)
  3&          bitwise AND with 3
    "-+*ⁿ"E   index into this string
           ƒ  call the respective function
— Mego
quelle
1

Oase , 25 Bytes

mn4%3Q*nkn4%2Q*nxn4%1Q*++

Probieren Sie es online!

Wie es funktioniert

Beachten Sie, dass x&3entspricht x%4, wo %Modulo ist.

mn4%3Q*nkn4%2Q*nxn4%1Q*++  input is n
mn4%3Q*                    (n**n)*((n%4)==3)
       nkn4%2Q*            (n**2)*((n%4)==2)
               nxn4%1Q*    (n*2)*((n%4)==1)
                       +   add the above two
                        +  add the above two

Oasis ist eine stapelbasierte Sprache, in der jedes Zeichen ein Befehl ist.

— Undichte Nonne
quelle
1

C #, 42 Bytes

x=>x%4<2?x*x%4<1?0:2:Math.Pow(x,x%4<3?2:x)

Eigentlich ist es normales C #, aber da Sie es nicht als ganzes Programm ausführen können und es in das interaktive Programm eingeben müssen, können Sie es auch als interaktives C # bezeichnen .

Erklärung :

x => (x % 4) < 2     //If the bits are smaller than 2 (1 or 0)
? x *           //multiply x with
    (x % 4) < 1 //if the bits are 0
    ? 0         //0 (results in 0)
    : 2         //or else with 2 (results in 2*x or x+x)
: Math.Pow(x,   //otherwise power x by
    (x % 4) < 3 //if the bits are 2
    ? 2         //2 (results in x^2 or x*x)
    : x);       //or else x (results in x^x)

Ich kann nicht sagen, ob es sich um die kürzeste Variante handelt. Vorschläge sind willkommen.

— MetaColon
quelle
Ich denke nicht, dass das gültig ist. Sie sollten im Allgemeinen ein Programm oder eine Funktion einreichen . Snippets sind standardmäßig nicht zulässig.
— Cyoce
@Cyoce Es ist ein Programm. Sie müssen es nur über das interaktive Programm ausführen, das das Programm interpretiert.
— MetaColon
Wenn ich dies interaktiv ausführe, erhalte ich eine Fehlermeldung, da diese xnicht definiert ist. Das macht dies zu einem Ausschnitt, nicht zu einem vollständigen Programm.
— Cyoce
@Cyoce In der Challenge wurde eine Variable x definiert.
— MetaColon
Das bedeutet das nicht. „Eine positive ganze Zahl Gegeben xMittel“ , dass Sie werden gegeben x durch einen Standard - Eingabeverfahren ( das heißt, die Funktion oder das Programm).
— Cyoce
1

C 115 Bytes

#include<math.h>
#define D(K,L)K(x){return L;}
D(q,0)D(w,x+x)D(e,x*x)D(r,pow(x,x))(*g[])()={q,w,e,r};D(f,g[x%4](x))

Beispiel ist eine Funktion int f(int x)

Es gibt vor, die schnellste Arbeitsgeschwindigkeit zu haben, da es die CPU davon abhält, bedingte Sprünge auszuführen. Und das ist nur der richtige Weg zur Geschwindigkeitsoptimierung für diese Aufgabe. Es wird auch versucht, nicht alles auszuwerten, wie im Beispiel von Array C, return(int[]){0,x+x,x*x,pow(x,x)}[x%4];sondern Array von Zeigern zu Funktonen sinnvoll zu verwenden, um mit viel schnellerer Adressarithmetik bedingungslose Sprünge (jmp / call) durchzuführen, als eine optimierte Version von " Schaltergehäuse..". Diese Technik kann auch in verschiedenen Arten von Finita-Automaten nützlich sein, z. B. in Prozessoremulatoren, Executoren, Befehlsstrom-Parsern usw., bei denen Geschwindigkeit und Code switch(x%4) case(0):... case(1):... ungeeignet sind, da sie mehrere cmp / jnz-Anweisungen erzeugen. und dies sind kostspielige Operationen für die CPU

Das einfachste und kürzeste Testprogramm (unter Standardbedingungen) für diesen Fall lautet wie folgt:

D(main,f(x))

Es werden nur 12 Bytes Nutzlast hinzugefügt, und unsere Gesamtgröße beträgt 127 Bytes.

Sie sollten den Linker jedoch anweisen, die fFunktion statt als Einstiegspunkt zu verwendenmain . Das ist die Art und Weise, wenn wir versuchen, aus dem kürzesten Code die schnellstmögliche Binärfunktion für diese Aufgabe zu erhalten ;-) Dies geschieht, weil die C-Bibliothek vor dem Aufrufen Ihrer main () -Funktion zusätzlichen Init / Shutdown-Code hinzufügt.

Code wird auf MSVS Community 2015 ohne Tricks und Probleme kompiliert und liefert korrekte Ergebnisse. Ich habe es nicht mit gcc getestet, aber ich bin sicher, es wird auch gut funktionieren.

1
Willkommen bei PPCG! Ziel dieser Herausforderung ist es, Ihren Code so kurz wie möglich zu halten. In diesem Fall kann Ihr Code durch die Kombination all dieser Funktionsdeklarationen leicht um ein Vielfaches verkürzt werden. Sie können auch Leerzeichen entfernen.
— HyperNeutrino
Ich mag die Idee, Zeiger auf Funktionen zu verwenden
— RosLuP
@RosLuP ye, aber es ist fast doppelt so lang wie Ihre 60-Byte-Version. aber es funktioniert viel schneller, es ist seine Größe wert.
@Hyper Neutrino Okay. Ich habe es mehr komprimiert. Scheint, das ist die endgültige Version! Es gibt keine Bugs, alle Tests bestanden 8-)
@ xakepp35 hast du gemessen dein ist schneller als mein?
— RosLuP
1

R, 47 42 Bytes

x=scan();c(`-`,`+`,`*`,`^`)[[x%%4+1]](x,x)

Wendet die Funktion -, +,* , oder ^auf der Basis des E - Modul xauf xund x.

-ist die einzige (etwas) kluge Sache, da x-ximmer 0 ist.

R, 33 Bytes

pryr::f(c(0,2*x,x^2,x^x)[x%%4+1])

Gleiche Methode wie andere Leute. Obwohl es kürzer ist, mag ich es bei weitem nicht so sehr.

— JAD
quelle
0

Pyth , 12 Bytes

.vjd,+@"-+*^

Probieren Sie es online!

Wie es funktioniert

Beachten Sie zunächst, dass x&3entspricht x%4, wo %Modulo ist. Da Pyth dann modular indexing ( a[n] == a[n+len(a)]) verwendet, müssen wir uns damit nicht einmal befassen.

Dann:

  • If x%4==0, return x-x(aus Konsistenzgründen);
  • Wenn x%4==1, kehre zurück x+x;
  • Wenn x%4==2, kehre zurück x*x;
  • Wenn ja x%4==3, kehre zurück x^x.
.vjd,+@"-+*^  example input: 10
      @"-+*^  "-+*^"[10], which is "*"
     +        "*10"
    ,         ["*10","10"]
  jd          "*10 10"
.v            evaluate as Pyth expression
              (Pyth uses Polish notation)

Weitere Informationen zur polnischen Notation: Wikipedia (schade, wenn Sie in der Türkei sind).

— Undichte Nonne
quelle
Huh? Das kommt mir einfach zu viel vor. Siehe meine Antwort für Details.
— Erik der Outgolfer
0

Vim, 50 Bytes

y$o^R"A-+*^^V^[0^R"lx0"_Dp^[0D@"kJ0"ad$:r!echo ^R"^R0|bc^<Enter>

Hier ^Vrepräsentiert a Ctrl+V, ^Rrepräsentiert Ctrl-Rund ^[repräsentiert dasesc Schlüssel

Arbeiten, indem Sie zuerst den Ausdruck aufbauen und dann lassen bc ihn auswerten. Erwartet die Eingabe in der ersten Zeile in einem ansonsten leeren Puffer.

Erläuterung:

y$o^R"                                                          Copies the input into register " and pastes it on the second line
      A-+*^^V^[0^R"lx0"_Dp                                      Enters that text after the input on the second line
                          ^[0D@"                                Executes the second line as a Vim command.
                                                                For example, if the input is 12, the second line would be 12A-+*^^[012lx0"_Dp, which means:
                                                                  12A-+*^^[           Insert the text -+*^ 12 times
                                                                           012lx0"_Dp Go 12 chars to the right and remove everything except for that.
                                                                If effect, this basically just selects the appropriate operation.
                                kJ0"ad$                         Put the operator after the number, cut it into register a
                                       :r!                      Execute the following shell command and put the result into the buffer:
                                          echo ^R"^R0|bc<Enter> The shell command "echo [contents of register a][contents of registers 0]|bc. As said above, register a contains the input and the operator, and register 0 contains the input. The <enter> then executes this command.
— Loovjo
quelle
Wenn ich tippe ^V, wird einfach eingefügt, was ich in meiner Zwischenablage habe, anstatt der Nummer ...
— Undichte Nonne
1
Probieren Sie es online! Sie können auch Danstelle vond$
— DJMcMayhem
0

Pyth, 9 Bytes

@[0yQ*QQ^

Testsuite

Hier ist nichts Besonderes los, berechnen Sie einfach die vier Werte und wählen Sie einen mit modularer Indizierung aus.

@[0yQ*QQ^
@[0yQ*QQ^QQ)Q    Implicit variable introduction
@           Q    Modularly index into the following list
 [0        )     0
   yQ            Q*2
     *QQ         Q*Q
        ^QQ      Q^Q
— isaacg
quelle
0

Batch, 135 Bytes

@set/an=%1*2^&6
@goto %n%
:6
@set n=1
@for /l %%i in (1,1,%1)do @set/an*=%1
@goto 0
:4
@set n=%1
:2
@set/an*=%1
:0
@echo %n%

Ich hatte gehofft, die Potenzierung durch Aufbauen und Auswerten eines Strings der Form in [0+...+0, 2+...+2, x+...+x, x*...*x]Abhängigkeit von den letzten beiden Bits zu xerzeugen, aber leider dauerte es zu lange, den Code zum Auswählen der Operation auszudrücken, da ich ihn nicht *als forParameter verwenden konnte, was ich aber tat Zumindest in der Lage, einige Fall-obwohl-Tricks zu verwenden, um einige Bytes wegzuspielen.

— Neil
quelle
0

Retina , 87 Bytes

.+
$*1;$&$*
;((1111)*)(1?)$
;$3$3
1(?=1.*;((1111)*111)$)
$1;
+`\G1(?=.*;(1*))|;1*$
$1
1

Probieren Sie es online! (Link enthält Testsuite.)

Erläuterung: Die ersten beiden Zeilen konvertieren die Eingabe in eine unäre und duplizieren sie (so haben wir es jetzt x;x). Die nächsten beiden Zeilen suchen nach einemx&3 von entweder 0oder 1und ändern sich x;xin x;0oder x;2entsprechend. Die nächsten beiden Zeilen suchen x&3==3und ändern sich x;xin x;x;x;...;x;1;x( x xs). Dies bedeutet , dass wir entweder x;0, x;2, x;x, oder , x;...;xund es bleibt zu multiplizieren alles zusammen und konvertieren zurück in Dezimalzahlen. (Der Multiplikationscode basiert auf dem im Retina-Wiki, wurde jedoch geändert, um die Multiplikation mit Null zu behandeln.)

— Neil
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.