Schreiben Sie eine Funktion oder ein Programm, die bzw. das eine einfache Arithmetik (Addition, Subtraktion, Multiplikation und Division) sowohl in Basis 10 als auch in Basis 2 ausführen kann.

Die Funktion nimmt einen mathematischen Ausdruck als Eingabe und gibt das richtige Ergebnis in der richtigen Basis aus. Bei der Eingabe handelt es sich um nZahlen, die durch einen oder mehrere Operatoren ( + - * /) getrennt werden.

Wenn alle Eingabewerte nur 0 und 1 enthalten, werden alle Werte als binär betrachtet. Wenn mindestens eine Ziffer vorhanden ist 2-9, werden alle Werte als Basis 10 betrachtet.

Regeln:

• Sie können davon ausgehen, dass es nur einen Operator zwischen den Nummern gibt ( 10*-1wird nicht angezeigt).
• Sie können davon ausgehen, dass es keine Klammern gibt.
• Normale Operatorrangfolge (im Zweifelsfall den Ausdruck im Google-Rechner verwenden).
• Sie können nicht davon ausgehen, dass es nur ganze Zahlen geben wird
• Es gibt keine führenden Nullen in der Eingabe oder Ausgabe
• Sie können davon ausgehen, dass nur gültige Eingaben gemacht werden
• Sie können davon ausgehen, dass alle Eingabewerte positiv sind (der Minus-Operator kann jedoch eine negative Ausgabe ermöglichen 1-2=-1und 10-100=-10).
• REPL wird nicht akzeptiert
• Sie können die Eingabe als separate Argumente oder als einzelnes Argument verwenden, die Eingabe muss jedoch in der richtigen Reihenfolge erfolgen.
  • Dh Sie repräsentieren kann 1-2mit den Eingabeargumente 1, -, 2, aber nicht 1, 2, -.
• Sie müssen die Symbole akzeptieren + - * /in der Eingabe, nicht plus, minususw.
• Sie müssen Gleitkommawerte unterstützen (oder bis zur maximalen Grenze Ihrer Sprache, es werden jedoch keine Ganzzahlen unterstützt).
• eval ist akzeptiert

Beispiele:

1+1
10

1010+10-1
1011

102+10-1
111

1+2+3
6

10*10*10
1000

11*11*11
11011

10*11*12+1
1321

10.1*10.1
110.01

20.2*20.2
408.04

10/5
2

110/10
11

Also accepted (optional line or comma-separated input):
10
+
10
-
1
11    <-- This is the output

Dies ist Codegolf, also gewinnt der kürzeste Code in Bytes.

Japt, 77 72 62 60 62 ^* 60 59 51 Bytes

OvUf"[2-9]" ?U:"({Ur"[\\d.]+""º$&e14+P n2 /2pE¹"})¤

Erklärung (mehr oder weniger die gleiche wie für die JS-Antwort):

Ov                       //eval...
  Uf"[2-9]"              //if input contains the digits 2 to 9
    U:                   //then it's base 10, just compute
    Ur"[\\d.]+"          //otherwise replace all the numbers
    "º$&e14+P n2 /2pE¹"  //with their base 10 equivalents
                         //I.e., take every number, multiple by 10^14, convert to
                         //base 10 and divide by 2^14
                         // º and ¹ are multiple brackets
    ¤                    //means "s2", i.e. convert the result to binary

Probieren Sie es online!

^{* nicht richtig geteilt}

JavaScript ES6, 87 97 ¹ 100 ² 106 ³ 102 101 98 100 ⁴ 93 88 86 Byte

e=>eval(e.match`[2-9]`?e:`(${e.replace(/[\d.]+/g,"('0b'+$&e14)/16384")}).toString(2)`)

Demo + Erklärung:

function c(e){
    return eval(                        
      e.match`[2-9]`?                  //check if there are numbers 2 to 9
        e:                             //if there're, just compute the result
        "("+                           
         e.replace(                    //otherwise replace...
           /[\d.]+/g,                  //any number...
           "(('0b'+$&e14)/16384)"    //...with itself converted to base 10
         )
        +").toString(2)"               //compute the result and convert it to binary
    )
}

document.write(
   c("1.1*1.1")+"<br>"+
   c("1010+10-1")+"<br>"+
   c("102+10-1")+"<br>"+
   c("1+2+3")+"<br>"+
   c("10*10*10")+"<br>"+
   c("11*11*11")+"<br>"+
   c("10*11*12+1")+"<br>"+
   c("10.1*10.1")+"<br>"+
   c("20.2*20.2")+"<br>"+
   c("10/5")+"<br>"+
   c(`10
      +
      10
      -
      1`)
)

^{1 - Floats vergessen
2 - Floats-Problem erneut: parseInt Floors binär, daher muss ich mit 1e14 multiplizieren und dann durch 16384 dividieren
3 - Ich hoffe, dass die vorgegebene Aufgabe erfüllt ist, fange jetzt mit dem Golf an: D
4 - Es gab einen Fehler beim Teilen}

Jolf, 31 Bytes, nicht konkurrierend

Ich habe eine anständige Anzahl von Funktionen hinzugefügt, die von dieser Herausforderung inspiriert sind, und daher wird sie als nicht konkurrierend angesehen. Ich bin glücklich, weil ich endlich unäre Funktionen implementiert habe (wie (H,S,n)=>valin ES6, aber in ES5 unterstützt!)

? hi"[2-9]"~eiB~epT mpvid|m'H2H
? hi"[2-9]"                     if the input contains any of 2..9
           ~ei                   evaluate i (implicitly print)
                                else
                   _mpvid        map the input split into number groups
                          m'H2    to H as a binary float
                         |    H   (or keep H, if that doesn't work)
                 pT              join by spaces
               ~e                evaluate
              B                  convert to binary (implicitly print)

Testsuite , versuchen Sie Ihren eigenen Eingang , oder manuell den Eingang eingestellt .

Bash, 60 Bytes

[ -z `tr -dc 2-9<<<$1` ]&&s='obase=2;ibase=2;';bc -l<<<$s$1

Beispiellauf:

$ ./bin_dec_add.sh 1+1
10
$ ./bin_dec_add.sh 1+2
3

𝔼𝕊𝕄𝕚𝕟 2, 46 Zeichen / 72 Bytes

ë(ïđ/[2-9]⎞?ï:`(⦃ïē/[\d.]+⌿,↪(Յ+$*ḊⁿḎ)/Ẁ²)})ⓑ`

Try it here (Firefox only).

Erläuterung

ë(ïđ/[2-9]⎞?ï:`(⦃ïē/[\d.]+⌿,↪(Յ+$*ḊⁿḎ)/Ẁ²)})ⓑ` // implicit: ï=input, Ḋ=10, Ḏ=14, Ẁ=128
ë(                                              // eval
  ïđ/[2-9]⎞?                                    // does ï have 2-9?
            ï                                   // if so, eval input
             :                                  // else, eval:
              `(⦃ïē/[\d.]+⌿,                    // replace the binary numbers
                                                // with their base 10 equivalents:
                            ↪(Յ+                // translates to `0b`
                                $*ḊⁿḎ           // matched number * 10^14
                                     )/Ẁ²       // divided by 128^2
                                         )})ⓑ` // converted to binary
                                                // implicit output

PowerShell, 107 Byte

param($e)iex(("{0}String($($e-replace'(\d+)','{0}Int32("$1",2)'),2)"-f'[Convert]::To'),$e)[$e-match'[2-9]']

Ungolfed

param($e) # Accept single argument
Invoke-Expression # Eval
  ( # Expression, resulting in an array of 2 elements
    (
      "{0}String( # Binary
        $( # Inline subexpression
          $e -replace'(\d+)', '{0}Int32("$1",2)'
          # "1010+10-1" becomes "{0}Int32("1010",2)+{0}Int32("10",2)-{0}Int32("1",2)"
        )
      ,2)"
      -f '[Convert]::To'
      # "{0}Int32("1010",2)+{0}Int32("10",2)-{0}Int32("1",2)" becomes
        "[Convert]::ToString([Convert]::ToInt32("1010",2)+[Convert]::ToInt32("10",2)-[Convert]::ToInt32("1",2),2)"
    ),
      $e # Plain
    )
    [$e-match'[2-9]'] # Return 1st element of array if regex matches, else 0

Beispiel

PS > .\Calc.ps1 1010+10-1
1011

PS > .\Calc.ps1 20.2*20.2
408,04