Aus dem Wikipedia-Artikel :

Die Ortsarithmetik (lateinisch arithmeticæ localis) ist das additive (nicht-positionsbezogene) binäre Zahlensystem, das John Napier in seiner Abhandlung Rabdology (1617) symbolisch und auf einem schachbrettartigen Gitter als Berechnungstechnik erforschte.

Was?

Mit Ortsziffern können Zahlen mit Buchstaben des Alphabets geschrieben werden.

Die Binärnotation war noch nicht standardisiert, weshalb Napier für die Darstellung von Binärzahlen sogenannte Positionsnummern verwendete. Das Napier-System verwendet die Zeichenwertnotation zur Darstellung von Zahlen. Es werden aufeinanderfolgende Buchstaben des englischen Alphabets verwendet, um aufeinanderfolgende Zweierpotenzen darzustellen: a = 2 ^ 0 = 1, b = 2 ^ 1 = 2, c = 2 ^ 2 = 4, d = 2 ^ 3 = 8, e = 2 ^ 4 = 16 und so weiter.

Ein Beispiel

ab = 1 + 2 = 3 in der Basis 10

aabb = 1 + 1 + 2 + 2 = 6 in der Basis 10

Beachten Sie, dass aabbdies bcdurch Ersetzen von 2 Instanzen eines Buchstabens durch eine höhere verkürzt werden kann .

Zusatz

Sie verketten einfach die beiden Zahlen und vereinfachen.

acd+ bde= acdbde= abcdde= acebe= abcf= 39in der Basis 10

Subtraktion

Entfernen Sie einfach alle Ziffern, die in beiden Teilen der Subtraktion gleich erscheinen. Das Erweitern (Konvertieren bin aa) kann erforderlich sein

abde- ad= be= 18 in der Basis 10

Multiplikation

Das ist etwas schwieriger.

Nehmen wir an, wir wollen acd(13) mit def(56) multiplizieren . Zuerst ordnen Sie acdvertikal an:

a
c
d

Dann fügen Sie defnach dem ersten hinzu a:

a def
c
d

Jetzt ist c 2 Stellen später im Alphabet als a, also addieren wir 2 Stellen im Alphabet, um defzu machen fgh. Das wird zur zweiten Zeile hinzugefügt.

a def
c fgh
d

Schließlich ist d 1 Stelle später im Alphabet als c, also addieren wir 1 Stelle im Alphabet, um fghzu machen ghi. Das wird der dritten Zeile hinzugefügt.

a def
c fgh
d ghi

Dann nimmst du die Summe von rechts: def+ fgh+ ghi= deffgghhi= deggghhi= deghhhi= deghii= deghj(728)

Ein weiteres Beispiel für die Multiplikation

Eingang:

bc * de

Zuerst:

b
c

Dann

b ef
c 

Dann

b ef
c fg

Beachten Sie, dass wir efin der ersten Zeile notiert haben. Das liegt daran, dass es mit bcbeginnt bund bder zweite Buchstabe im Alphabet ist. Wir müssen also um einen deBuchstaben verschieben, damit es wird ef.

Dann

ef+fg

Ausgabe:

eh

Teilung

Dies ist nicht Teil dieser Herausforderung, da es sehr komplex werden kann.

Deine eigentliche Herausforderung

Ihr Programm oder Ihre Funktion muss Eingaben als Zeichenfolge annehmen, die wie folgt aussieht:

a + b

Und Sie müssen Folgendes ausgeben:

ab

Natürlich muss Ihr Programm oder Funktionsnummern beliebiger Länge unterstützen (bis auf den String oder Eingabegrenze Ihrer Sprache) mit einem der Betreiber +, -oder *. Einige weitere Beispiele:

Eingang:

ab + bd

Ausgabe:

acd

Eingang:

d - ab

Ausgabe:

ac

Eingang:

ab * cd

Ausgabe:

cf

Anmerkungen:

• Die Reihenfolge der Buchstaben in der Ausgabe spielt keine Rolle, aber Sie können immer davon ausgehen, dass die Reihenfolge der Buchstaben in den Zahlen in der Eingabe aufsteigend ist (a vor z).
• Sie können Eingaben mit einem nachgestellten Zeilenumbruch und Ausgaben mit einem nachgestellten Zeilenumbruch vornehmen.
• Sie können nicht Eingabe als eine Liste von nehmen ab, *und bdfür ab * bd.
• Das englische Alphabet wird verwendet ( abcdefghijklmnopqrstuvwxyz)
• Ihre Ausgabe muss vereinfacht werden ( aaist nicht erlaubt, bist erforderlich)
• Die Eingabe wird vereinfacht ( b+ c, nicht aa+ bboder aa+ aaaa)
• Sie können einen Platz benötigen , bevor und den Betreiber ( +, -oder *), oder man kann es keine sein müssen.
• Es wird nur einen Operator pro Eingabe geben.
• Sie können davon ausgehen, dass die Ausgabe und die Eingabe niemals über 2 ^ 27-1 ( abcdefghijklmnopqrstuvwxyz) hinausgehen werden.
• Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes!

Jelly , 26 25 Bytes

i@€Øað’2*S;ḟ.Ḣ
ḲÇ€VBṚTịØa

Verwendet Jelly Operatoren ( ×statt *und _statt -) in der Eingabezeichenfolge als durch die OP erlaubt .

(Benötigt Leerzeichen um die Operatoren)

Probieren Sie es online! oder sehen Sie sich die Testsuite an

Wie?

i@€Øað’2*S;ḟ.Ḣ - Link 1, transform from input sub-string to value or operator: sub-string
i@€            - 1st index of, for €ach (or 0 if not found) [reversed @rguments] in:
   Øa          -      lowercase alphabet (i.e. a->1, b->2, ..., non-alpha->0)
     ð         - dyadic chain separation i.e. f(result above, substring):
      ’        - decrement (i.e a->0, b->1, ..., non-alpha->-1)
       2*      - 2 raised to that power
         S     - sum
          ;    - concatenate with the substring
           ḟ   - filter out:
            .  -     0.5 (for an operator substring the evaluated 0.5 is removed)
             Ḣ - head (i.e. the evaluation for a location, and the operator otherwise)

ḲÇ€VBṚTịØa - Main link: string                        e.g. 'ab × cd'
Ḳ          - split on spaces                               [['a','b'],['×'],['c','d']]
 Ç€        - last link (1) as a monadic function for €ach  [3,'×',12]
   V       - evaluate as Jelly code                        36
    B      - convert to binary                             [1,0,0,1,0,0]
     Ṛ     - reverse                                       [0,0,1,0,0,1]
      T    - truthy indexes                                [3,6]
       ị   - index into:
        Øa -     lowercase alphabet                        ['c','f'] (i.e. "cf", which is implicitly printed when run as a full program)

Mathematica, 168 Bytes

FixedPoint[StringReplace[x_~~x_:>FromCharacterCode[c@x+1]],Table["a",ToExpression@StringReplace[#,x:LetterCharacter..:>ToString@Tr[2^((c=ToCharacterCode)@x-97)]]]<>""]&

Meine ursprüngliche Lösung (bevor der Beitrag bearbeitet wurde, um zu verdeutlichen, dass die Ausgabe vereinfacht werden muss) war um 64Bytes kürzer:

Table["a",ToExpression@StringReplace[#,x:LetterCharacter..:>ToString@Tr[2^(ToCharacterCode@x-97)]]]<>""

Dies änderte gerade diese Lösung, um zu arbeiten. Es ist wahrscheinlich kürzer, die in der Herausforderung beschriebenen Methoden tatsächlich anzuwenden, aber ich wollte das trotzdem ausdrücken.

Erläuterung:

Ersetzt jede Folge von Buchstaben durch die entsprechende Ganzzahl durch eine Zeichencode-Arithmetik, konvertiert die resultierende Zeichenfolge in einen Ausdruck (der sich automatisch in eine Ganzzahl vereinfacht), erstellt dann eine Zeichenfolge mit ader gleichen Länge wie diese Ganzzahl und ersetzt schließlich benachbarte identische Zeichen Zeichen mit dem nächsten Zeichencode, bis ein fester Punkt erreicht ist.

JavaScript (ES6), 136 134 133 Bytes

Dank Luke 1 Byte gespeichert

s=>[...a='abcdefghijklmnopqrstuvwxyz'].filter((c,i)=>eval(s.replace(/\w+/g,s=>[...s].reduce((p,c)=>p|1<<a.search(c),0)))&1<<i).join``

Testfälle

let f =

s=>[...a='abcdefghijklmnopqrstuvwxyz'].filter((c,i)=>eval(s.replace(/\w+/g,s=>[...s].reduce((p,c)=>p|1<<a.search(c),0)))&1<<i).join``

console.log(f('ab + bd'));  // acd
console.log(f('d - ab'));   // ac
console.log(f('ab * cd'));  // cf

Perl 5 , 95 Bytes

94 Byte Code + -pFlag.

s/\w/a x 2**(-97+ord$&)/ge;s/(.*)-\1|\+//;/\*/&&($_=$`x length$');1while s/(.)\1/chr 1+ord$1/e

Probieren Sie es online!

Drei Schritte hier:
- s/\w/a x 2**(-97+ord$&)/ge;Konvertiert die Eingabe in eine Zeichenfolge von anur.
- s/(.*)-\1|+//;/*/&&($_=$`x length$')führt den Operator aus (das sind sehr einfache Zeichenfolgen a): +Ist die Verkettung -das Entfernen von so vielen aus dem ersten Teil, awie es im zweiten Teil gibt, und *das Duplizieren des ersten Teils, so oft es aim zweiten Teil gibt Teil.
- 1while s/(.)\1/chr 1+ord$1/efaltet die aufeinanderfolgenden gleichen Buchstaben in den nächsten Buchstaben des Alphabets.

05AB1E , 29 Bytes

ð¡À¬U¦v0yvAyko+}}X.VbRvyiANèJ

Probieren Sie es online! oder als Testsuite

Erläuterung

ð¡                             # split input on string
  À                            # rotate left
   ¬U¦                         # get the operator, store it in X and remove it from list
      v                        # for each side of the equation
       0                       # push 0 as an accumulator
        yv                     # for each letter in each side of the equation
          Ayk                  # get its index in the alphabet
             o                 # raise 2 to this power
              +                # add to the accumulator
               }}              # end loops
                 X.V           # apply the operator to the 2 numbers now on the stack
                    bR         # convert to binary and reverse
                      v        # for each binary digit
                       yi      # if it is true
                         ANè   # get the letter at that index in the alphabet
                            J  # join stack to a single string

C & x86 asm, 340 Bytes

Übersetzen Sie mit -O0

#define G getchar()
g(){int c,a=0;for(;islower(c=G);)a+=1<<(c-97);return a;}
main(){short o[]={[43]=0x4403,[45]=0x442b,[42]=0x6cf7};
mprotect((long)&&l&~4095,4096,7);
for(;;){int c,b=0,a=g();*(short*)&&l=o[G];G;g();asm("xchg %%eax,%0":"+m"(a));
l:asm("addl %1,%%eax":"=a"(c):"m"(a));
for(;a=c>>b;b++)if(a&=1)putchar(97+b);putchar(10);}}

Erläuterung

Da C keine hat eval(), habe ich stattdessen eine Tabelle mit x86-Anweisungen verwendet. Ich musste Anweisungen auswählen, die alle die gleiche Länge hatten (oder mit Nops aufgefüllt waren), und die dieselbe Quelle und dasselbe Ziel erwarteten. Besonders ärgerlich war, dass MUL nur in Register schreiben kann und die 1-Byte-MUL-Opcodes nur in EAX schreiben können. Außerdem schien es keinen register-schreibenden SUB-Befehl zu geben, der vom Speicher subtrahierte, anstatt umgekehrt, daher der XCHG.

bearbeiten

Da es in den Kommentaren gefragt wurde, würde eine traditionellere Herangehensweise so aussehen:

#define G getchar()
#define return r
#define int i
g(){i c,a=0;for(;islower(c=G);)a+=1<<(c-97);r a;}
a(i x,i y){r x+y;}s(i x,i y){r x-y;}m(i x,i y){r x*y;}
main(){i(*o[])(i,i)={[43]=a,[45]=s,[42]=m};
for(;;){i c,b,a=g();b=G;G;g();c=o[b](a,g());
for(b=0;a=c>>b;b++)if(a&=1)putchar(97+b);putchar(10);}}

Aus folgenden Gründen ist es mit 301 Zeichen etwas kürzer: 1. Da viele Funktionen erforderlich sind, kann der Overhead der einzelnen Funktionen mit einigen Präprozessorregeln reduziert werden. 2. Modernes Linux schützt vor der Ausführung auf dem Stack, so dass der Aufruf von mprotect () diese geopferten 34 Bytes deaktiviert. 3. Der XCHG-Aufruf ist sehr suboptimal und kostet weitere 30 Byte. Wäre dies nicht der Fall, würde die x86-Combo etwa 10 bis 20 Byte gewinnen.

Außerdem wurden 2 Bytes von beiden durch Verbessern des islower () -Aufrufs in g gehackt.

GNU sed + coreutils, 329 Bytes

Ja, ich habe keine Ahnung, was in mich gefahren ist, aber ich kenne sed scripting jetzt ein bisschen besser. Beachten Sie, dass diese Lösung die eErweiterung von GNU sed erfordert , die einen Shell-Befehl ausführt.

/\+/{s/\+//
b S}
/-/{:E
/a+-a+/{s/(a*)(a*)-\2/\1/
b S}
s/.*/echo &|tr b-z- A-Y-/
e
s/([A-Z])/\L\1\1/g
b E}
/\*/{h
:M
/^\*/{x
s/[^\n]*//
s/\n//g
b S}
s/(.).*\*(.*)/echo \2|tr a-z \1-za-z/
e
H
g
s/.(.*)/\1/
h
s/\n.*//
b M}
:S
s/^.*$/echo &|grep -o .|sort|tr -d '\n'/
e
:L
s/(.)\1/\u\1/g
/^[a-z]*$/ q
s/.*/echo &|tr A-Z b-za/;e
b L

Ich gehe davon aus, dass es keine Leerzeichen um die Operatoren geben wird. Von meinem Terminal:

$ sed -rf golf.sed <<< a+b
ab
$ sed -rf golf.sed <<< ab+bd
acd
$ sed -rf golf.sed <<< abc+b
ad
$ sed -rf golf.sed <<< d-ab
ca
$ sed -rf golf.sed <<< ab*cd
cf
$ sed -rf golf.sed <<< bc*de
eh
$ sed -rf golf.sed <<< acd*def
deghj

Und für diejenigen, die vernünftiger sind als ich: die kommentierte Version!

#!/bin/sed -rf

/\+/ {
    s/\+//
    b simplify
}

/-/ {
    # expand pattern space; everything will now be 'a's
    :E
    /a+-a+/{
        # Remove doubled 'a's on either side of the dash. For example,
        # for input d-ab, space is now 'aaaa-aaa'; substitute this to 'a'
        s/(a*)(a*)-\2/\1/
        b simplify
    }
    # shift letters that aren't 'a' down and double them
    s/.*/echo &|tr b-z- A-Y-/;e
    s/([A-Z])/\L\1\1/g
    b E
}

/\*/ {
    # Hold space: line 1 is pattern, other lines are output
    h
    :M

    # if space starts with *, we've eaten entire arg0; sum and simplify
    /^\*/ {
        x
        s/[^\n]*//      # remove first line, which is our pattern
        s/\n//g         # remove newlines to add results together
        b simplify
    }

    # convert pattern into shifting command
    s/(.).*\*(.*)/echo \2|tr a-z \1-za-z/

    # execute it, append result to hold space
    e
    H

    # restore pattern, with leading char and all output lines removed
    g
    s/.(.*)/\1/
    h
    s/\n.*//

    b M
}

:simplify
# reorder all letters so all 'a's are before all 'b's are before all 'c's
# are before ... etc    
# See /programming/2373874
s/^.*$/echo &|grep -o .|sort|tr -d '\n'/
e

:L
# Replace repeated characters with themselves upper-cased, then translate
# upper-cased characters to what they should be.
s/(.)\1/\u\1/g
/^[a-z]*$/ q
s/.*/echo &|tr A-Z b-za/;e
b L

PHP, 168

Ausgabe Aufsteigend bei Verwendung von eval

[$a,$o,$b]=explode(" ",$argn);function d($s){for(;$i<strlen($s);)$n+=2**(ord($s[$i++])-97);return$n;}for(eval("\$k=d($a)$o d($b);");$i<26;)echo$k&2**$i++?chr(96+$i):"";

PHP, 185 Bytes

Ausgabe aufsteigend

[$a,$o,$b]=explode(" ",$argn);function d($s){for(;$i<strlen($s);)$n+=2**(ord($s[$i++])-97);return$n;}for(;$i<26;)echo(bc.[mul,add,0,sub][ord($o)-42])(d($a),d($b))&2**$i++?chr(96+$i):"";

Online Version

Erweitert

[$a,$o,$b]=explode(" ",$argn); # part the input into variables
function d($s){ # make decimal value
    for(;$i<strlen($s);)$n+=2**(ord($s[$i++])-97);
    return$n;
}
for(;$i<26;)
echo(bc.[mul,add,0,sub][ord($o)-42])(d($a),d($b))&2**$i++?chr(96+$i):""; # Bitwise Compare and Output

PHP, 201 Bytes

Ausgang absteigend

[$a,$o,$b]=explode(" ",$argn);function d($s){for(;$i<strlen($s);)$n+=2**(ord($s[$i++])-97);return$n;}for($r=(bc.[mul,add,0,sub][ord($o)-42])(d($a),d($b));$r;$r-=2**$l)$t.=chr(97+$l=log($r,2)^0);echo$t;

Online Version

Erweitert

[$a,$o,$b]=explode(" ",$argn); # part the input into variables
function d($s){ # make decimal value
    for(;$i<strlen($s);)$n+=2**(ord($s[$i++])-97);
    return$n;
}
for(
$r=(bc.[mul,add,0,sub][ord($o)-42])(d($a),d($b)) # result of the operation
;$r;
$r-=2**$l) # subtract the letter value 
$t.=chr(97+$l=log($r,2)^0); # find greatest letter
echo$t; # Output

Python 3 , 176 167 Bytes

i=lambda a:str(sum(1<<ord(i)-97for i in a))
def f(a):
 a,b,c=a.split();m=eval(i(a)+b+i(c));r=''
 while m:
  t=0
  while m>=2**t*2:t+=1
  r+=chr(97+t);m-=2**t
 return r

Probieren Sie es online!

• 9 Bytes gespart: Danke an tutleman

PHP, 130

for($d=a;$e=$argn[$i++];)$e!=' '?$d!=b?$$d+=1<<ord($e)-97:$b=$e:++$d;eval("for(;\$j++<27;)echo($a$b$c>>\$j-1)&1?chr(96+\$j):'';");

erweiterte Version:

for($d=a;$e=$argn[$i++];)       // for each char in the input
  $e!=' '?                      //   if space
    $d!=b?                      //     if not the operation
      $$d+=1<<ord($e)-97:       //       add 2^(char - 'a')
      $b=$e:                    //     else save operation
    ++$d;                       //   else increase "pointer"
eval("for(;\$j++<27;)           // for each bit in the output
        echo($a$b$c>>\$j-1)&1?  //   calulate the result and check the bit
          chr(96+\$j):          //     output corrosponding char
          '';                   //     output nothing
     ");

renn mit php -R <code>.

AWK, 201 Bytes

BEGIN{RS="(.)"}n=index(V="abcdefghijklmnopqrstuvwxyz",RT){s+=2^--n}index("+-*",RT){a=s RT
s=0}END{RS="\n"
"(awk '$0="a s"'<<<1)"|getline v
for(j=26;j--;)if((s=v-2^j)>=0){v=s;c=substr(V,j+1,1)c}print c}

"(awk '$0="a s"'<<<1)"|getline vist der beste Weg , ich mit einem tun einfiel evaluatein AWK. Ich kann ein wenig "schummeln", um dies nur zu nennen AWK, da ich einen Befehl ausführe, aber zumindest ist der Befehl auch AWK:)

Ich bin sicher, ich vermisse einen Weg, um die Byteanzahl zu reduzieren, aber ich kann es sicher nicht sehen.

Die Verwendung ist ziemlich normal. Geben Sie beispielsweise den Code ein FILEund führen Sie Folgendes aus:

awk -f FILE <<< "bc + ab"

Beachten Sie, dass keine Leerzeichen erforderlich sind und alle Nicht-Op- / Nicht-Az-Zeichen stillschweigend ignoriert werden. Könnte durch Ändern der Schleife erweitert werden, um mit Zahlen zu arbeiten, die größer als "abcdefghijklmnopqrstuvwxyz" sind. Um eine Division /durchzuführen , fügen Sie einfach das Zeichen zur Operationszeichenfolge hinzu :). Außerdem wird eine leere Zeile gedruckt, wenn result <= 0.