Từ bài viết Wikipedia :

Số học vị trí (số học Latinhæ localis) là hệ thống số nhị phân phụ gia (không theo vị trí), mà John Napier đã khám phá như một kỹ thuật tính toán trong chuyên luận Rabdology (1617), cả về mặt tượng trưng và trên lưới giống như bàn cờ.

Gì?

Chữ số vị trí là một cách viết số bằng cách sử dụng các chữ cái của bảng chữ cái.

Ký hiệu nhị phân chưa được chuẩn hóa, vì vậy Napier đã sử dụng cái mà ông gọi là số vị trí để biểu thị số nhị phân. Hệ thống của Napier sử dụng ký hiệu giá trị ký hiệu để thể hiện các con số; nó sử dụng các chữ cái liên tiếp từ bảng chữ cái tiếng Anh để thể hiện sức mạnh liên tiếp của hai: a = 2 ^ 0 = 1, b = 2 ^ 1 = 2, c = 2 ^ 2 = 4, d = 2 ^ 3 = 8, e = 2 ^ 4 = 16 và cứ thế.

Một ví dụ

ab = 1 + 2 = 3 trong cơ sở 10

aabb = 1 + 1 + 2 + 2 = 6 trong cơ sở 10

Lưu ý rằng aabbcó thể rút ngắn bcbằng cách thay thế bất kỳ 2 trường hợp nào của một chữ cái bằng một chữ cái cao hơn.

Thêm vào

Bạn chỉ cần nối hai số và đơn giản hóa.

acd+ bde= acdbde= abcdde= acebe= abcf= 39trong cơ sở 10

Phép trừ

Chỉ cần loại bỏ tất cả các chữ số xuất hiện như nhau trong cả hai phần của phép trừ. Mở rộng (chuyển đổi bthành aa) có thể cần thiết

abde- ad= be= 18 trong cơ sở 10

Phép nhân

Cái này khó hơn một chút.

Hãy nói rằng chúng tôi muốn nhân acd(13) với def(56). Đầu tiên bạn sắp xếp acdtheo chiều dọc:

a
c
d

Sau đó, bạn thêm defsau đầu tiên a:

a def
c
d

Bây giờ, c là 2 vị trí sau trong bảng chữ cái hơn a, vì vậy chúng tôi thêm 2 vị trí trong bảng chữ cái defđể thực hiện fgh. Điều đó được thêm vào hàng thứ hai.

a def
c fgh
d

Cuối cùng, d là 1 vị trí sau trong bảng chữ cái so với c, vì vậy chúng tôi thêm 1 vị trí trong bảng chữ cái fghđể thực hiện ghi. Điều đó được thêm vào hàng thứ ba.

a def
c fgh
d ghi

Sau đó, bạn lấy tổng của quyền: def+ fgh+ ghi= deffgghhi= deggghhi= deghhhi= deghii= deghj(728)

Một ví dụ khác về phép nhân

Đầu vào:

bc * de

Đầu tiên:

b
c

Sau đó

b ef
c 

Sau đó

b ef
c fg

Lưu ý rằng chúng tôi đã viết xuống efdòng đầu tiên. Đó là bởi vì bcbắt đầu bằng b, và blà chữ cái thứ hai trong bảng chữ cái, vì vậy chúng ta cần thay đổi de1 chữ cái, để nó trở thành ef.

Sau đó

ef+fg

Đầu ra:

eh

Bộ phận

Đây không phải là một phần của thử thách này, vì nó có thể trở nên rất phức tạp.

Thử thách thực tế của bạn

Chương trình hoặc chức năng của bạn phải lấy đầu vào là một chuỗi trông như thế này:

a + b

Và bạn phải xuất ra:

ab

Tất nhiên, chương trình hoặc chức năng của bạn phải hỗ trợ số chiều dài tùy ý (lên đến chuỗi hoặc đầu vào giới hạn của ngôn ngữ của bạn) với bất kỳ của các nhà khai thác +, -hoặc *. Một số ví dụ khác:

Đầu vào:

ab + bd

Đầu ra:

acd

Đầu vào:

d - ab

Đầu ra:

ac

Đầu vào:

ab * cd

Đầu ra:

cf

Ghi chú:

• Thứ tự các chữ cái trong đầu ra không quan trọng, nhưng bạn luôn có thể giả định rằng thứ tự các chữ cái trong các số trong đầu vào sẽ tăng dần (a trước z).
• Bạn có thể nhận đầu vào với một dòng mới và đầu ra với một dòng mới.
• Bạn có thể không nhận các thiết bị như một danh sách ab, *và bdcho ab * bd.
• Bảng chữ cái tiếng Anh được sử dụng ( abcdefghijklmnopqrstuvwxyz)
• Đầu ra của bạn phải được đơn giản hóa ( aakhông được phép, blà bắt buộc)
• Đầu vào sẽ được đơn giản hóa ( b+ c, không phải aa+ bbhoặc aa+ aaaa)
• Bạn có thể yêu cầu một không gian trước và các nhà điều hành ( +, -hay *), hoặc bạn có thể yêu cầu có được không.
• Sẽ chỉ có một toán tử cho mỗi đầu vào.
• Bạn có thể cho rằng đầu ra và đầu vào sẽ không bao giờ vượt quá 2 ^ 27-1 ( abcdefghijklmnopqrstuvwxyz)
• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte sẽ thắng!

Thạch , 26 25 byte

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

Sử dụng các toán tử Jelly ( ×chứ không phải *và _hơn là -) trong chuỗi đầu vào như được OP cho phép .

(Yêu cầu không gian xung quanh các nhà khai thác)

Hãy thử trực tuyến! hoặc xem bộ kiểm tra

Làm sao?

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)

Toán học, 168 byte

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

Giải pháp ban đầu của tôi (trước khi bài viết được chỉnh sửa để làm rõ rằng đầu ra phải được đơn giản hóa) 64ngắn hơn byte:

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

Điều này chỉ cần sửa đổi giải pháp đó để làm việc. Có thể ngắn hơn để thực sự sử dụng các phương pháp được mô tả trong thử thách, nhưng dù sao tôi cũng muốn đưa nó lên.

Giải trình:

Thay thế từng chuỗi chữ cái bằng số nguyên tương ứng của nó bằng số học mã ký tự, sau đó chuyển đổi chuỗi kết quả thành một biểu thức (sẽ tự động đơn giản hóa thành một số nguyên), sau đó tạo ra một chuỗi các aký tự có độ dài bằng số nguyên đó và cuối cùng thay thế giống hệt nhau các ký tự có mã ký tự tiếp theo cho đến khi đạt đến một điểm cố định.

JavaScript (ES6), 136 134 133 byte

Đã lưu 1 byte nhờ Luke

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``

Các trường hợp thử nghiệm

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 byte

94 byte mã + -pcờ.

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

Hãy thử trực tuyến!

Ba bước ở đây:
- s/\w/a x 2**(-97+ord$&)/ge;chuyển đổi đầu vào thành một chuỗi achỉ.
- s/(.*)-\1|+//;/*/&&($_=$`x length$')sẽ thực thi toán tử (rất đơn giản trên chuỗi a): +là phép nối, -nghĩa là loại bỏ khỏi phần thứ nhất nhiều anhư trong phần thứ hai, và *có nghĩa là sao chép phần thứ nhất nhiều lần atrong phần thứ hai phần.
- 1while s/(.)\1/chr 1+ord$1/egấp các chữ cái giống nhau liên tiếp vào chữ cái tiếp theo trong bảng chữ cái.

05AB1E , 29 byte

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

Hãy thử trực tuyến! hoặc như một bộ thử nghiệm

Giải trình

ð¡                             # 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 byte

Biên dịch với -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);}}

Giải trình

Vì C không có eval(), tôi đã sử dụng bảng hướng dẫn x86 ở vị trí của nó. Tôi đã phải chọn các hướng dẫn có cùng độ dài (hoặc được đệm bằng nops) và dự kiến ​​src và đích cùng loại. Điều khó chịu đặc biệt là MUL chỉ có thể ghi vào các thanh ghi và các mã MUL 1 byte chỉ có thể ghi vào EAX. Ngoài ra, dường như không có lệnh SUB ghi bằng văn bản nào bị trừ khỏi bộ nhớ, thay vào đó là cách khác, do đó là XCHG.

chỉnh sửa

Vì nó đã được hỏi trong các ý kiến, một thẩm định truyền thống hơn sẽ trông như thế này:

#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);}}

Nó thực sự ngắn hơn một chút, ở mức 301 ký tự, vì một số lý do: 1. Vì cần phải có nhiều chức năng, nên mỗi chi phí có thể được cắt nhỏ với một số quy tắc tiền xử lý. 2. linux hiện đại bảo vệ khỏi thực thi trên ngăn xếp, vì vậy lệnh gọi mprotect () để vô hiệu hóa 34 byte đã hy sinh này. 3. Cuộc gọi XCHG rất tối ưu, tốn thêm 30 byte. Nếu không phải vì những điều đó, combo x86 sẽ giành được khoảng 10-20 byte.

Cũng cắt 2 byte từ cả hai bằng cách cải thiện lệnh gọi islower () trong g.

GNU sed + coreutils, 329 byte

Vâng, tôi không có ý tưởng gì về tôi, nhưng ít nhất bây giờ tôi biết sed kịch bản tốt hơn một chút. Lưu ý rằng giải pháp này yêu cầu ephần mở rộng của GNU sed , chạy lệnh shell.

/\+/{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

Tôi cho rằng sẽ không có không gian xung quanh các nhà khai thác. Từ thiết bị đầu cuối của tôi:

$ 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

Và, đối với những người vệ sinh hơn tôi: phiên bản nhận xét!

#!/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

Đầu ra tăng dần khi sử dụng 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 byte

Đầu ra tăng dần

[$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):"";

Phiên bản trực tuyến

Mở rộng

[$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 byte

Đầu ra quyết định

[$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;

Phiên bản trực tuyến

Mở rộng

[$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 byte

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

Hãy thử trực tuyến!

• đã lưu 9 byte: Nhờ người hướng dẫn

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):'';");

phiên bản mở rộng:

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
     ");

chạy với php -R <code>.

AWK, 201 byte

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 vlà cách tốt nhất mà tôi có thể đưa ra để làm một evaluatetrong AWK. Tôi có thể "gian lận" một chút để gọi điều này chỉ AWKvì tôi đang thực thi một lệnh, nhưng ít nhất lệnh cũng vậy AWK:)

Tôi chắc chắn rằng tôi đang thiếu một số cách để giảm số lượng byte, nhưng tôi chắc chắn không thể nhìn thấy nó.

Cách sử dụng khá chuẩn, ví dụ: đặt mã vào FILEvà làm:

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

Lưu ý rằng không gian là không bắt buộc và bất kỳ ký tự không op / non [az] nào sẽ bị bỏ qua trong âm thầm. Có thể được mở rộng để làm việc với các số lớn hơn "abcdefghijklmnopqrstuvwxyz" bằng cách thay đổi vòng lặp. Để thực hiện phép chia, chỉ cần thêm /ký tự vào chuỗi thao tác :). Ngoài ra, sẽ in một dòng trống nếu result <= 0.