Écrivez une fonction ou un programme qui peut faire de l'arithmétique simple (addition, soustraction, multiplication et division) en base 10 et en base 2.

La fonction prendra une expression mathématique en entrée et produira le résultat correct dans la base correcte. L'entrée sera des nnombres séparés par un ou plusieurs opérateurs ( + - * /).

Si toutes les valeurs d'entrée ne contiennent que 0 et 1, toutes les valeurs sont considérées comme binaires. Si au moins un chiffre est 2-9, toutes les valeurs sont considérées comme la base 10.

Règles:

• Vous pouvez supposer qu'il n'y aura qu'un seul opérateur entre les numéros ( 10*-1n'apparaîtra pas)
• Vous pouvez supposer qu'il n'y aura pas de parenthèses.
• Priorité normale de l'opérateur (essayez l'expression dans la calculatrice Google en cas de doute).
• Vous ne pouvez pas supposer qu'il n'y aura que des entiers
• Il n'y aura pas de zéros non significatifs en entrée ou en sortie
• Vous pouvez supposer que seule une entrée valide sera donnée
• Vous pouvez supposer que toutes les valeurs d'entrée sont positives (mais l'opérateur moins peut rendre possible une sortie négative, 1-2=-1et 10-100=-10)
• REPL n'est pas accepté
• Vous pouvez choisir de prendre l'entrée en tant qu'arguments séparés ou en tant qu'argument unique, mais l'entrée doit être dans le bon ordre.
  • -À- dire que vous pouvez représenter 1-2avec les arguments d'entrée 1, -, 2mais pas 1, 2, -.
• Vous devez accepter les symboles + - * /dans l'entrée, pas plus, minusetc.
• Vous devez prendre en charge les valeurs à virgule flottante (ou jusqu'à la limite maximale de votre langue, mais la prise en charge uniquement des nombres entiers n'est pas acceptée).
• eval est accepté

Exemples:

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

Il s'agit du code golf, donc le code le plus court en octets gagnera.

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

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

Explication (plus ou moins la même que pour la réponse JS):

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

Essayez-le en ligne!

^{* ne s'est pas divisé correctement}

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

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

Démo + explication:

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 -
J'ai oublié les flotteurs 2 - Encore une fois, le problème des flotteurs: analyser les étages binaires, donc je dois multiplier par 1e14 puis diviser par 16384
3 - J'espère que la tâche donnée est accomplie, commencez à jouer au golf: D
4 - il y avait un bug avec la division}

Jolf, 31 octets, sans concurrence

J'ai ajouté une quantité décente de fonctions inspirées de ce défi et, comme tel, il est considéré comme non compétitif. Je suis content car j'ai finalement implémenté des fonctions unaires (comme (H,S,n)=>valdans ES6, mais sont supportées dans ES5!)

? 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)

La suite de tests , Tentez votre propre entrée , ou régler manuellement l'entrée .

Bash, 60 octets

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

Exemple d'exécution:

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

𝔼𝕊𝕄𝕚𝕟 2, 46 caractères / 72 octets

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

Try it here (Firefox only).

Explication

ë(ïđ/[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 octets

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

Non golfé

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

Exemple

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

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