Giảm thiểu Brainfuck

Thách thức của bạn là giảm thiểu mã Brainfuck , theo các quy tắc sau:

• Loại bỏ bất cứ thứ gì không phải là một trong số đó +-><[].,.
• Đối với bất kỳ nhóm liên tiếp +hoặc -ký tự nào, nếu số lượng +s và -s là như nhau, hãy loại bỏ chúng.
• Làm tương tự như trên, nhưng với >và <.
• Xóa các chuỗi +-><ký tự nếu chúng không làm gì. Ví dụ, bạn nên loại bỏ +>-<->+<. (Đây có thể là cách khó nhất và khó nhất để thực hiện.) Hãy chắc chắn rằng bạn không nhận được bất kỳ thông tin sai nào, như +>-<+>-<, không nên xóa.

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

Đầu vào

++++++[->++++++<]>.   prints a $
[-]<                  resets tape
>,[>,]<[.<]           reverses NUL terminated input string
++-->><<              does nothing

Đầu ra

++++++[->++++++<]>.[-],[>,]<[.<]

Đầu vào

Should disappear: ++>>+<+++<->-->-<<->-<
Should disappear: +++>-<--->+<
Should stay: +++>-<+>---<

Đầu ra

+++>-<+>---<

Bạn có thể chấp nhận đầu vào và đầu ra theo cách bạn muốn - stdin / stdout, một hàm, v.v., nhưng đầu vào có thể không được mã hóa cứng.

Đây là môn đánh gôn , vì vậy mã ngắn nhất về số lượng nhân vật sẽ giành chiến thắng.

REBEL - 104

_/^_$/$</([^][<>.,+-]|\+-|-\+|<>|><)//((?<X>(<|>))+[+-]+(?!\2)(?<-X><|>)+(?(X)(?!)))([+-]+)/$3$1/.+/$>$&

Sử dụng:

Đầu vào: Đọc một dòng từ stdin.

Đầu ra: In một dòng thành thiết bị xuất chuẩn.

Bất thường *:

• Nhập _làm cho một dòng khác được đọc và sử dụng, thay vì xuất ra không có gì.
• Các thử nghiệm đầu ra thứ hai ++++>----<thay vì +++>-<+>---<. Nhưng điều đó ổn, phải không? ;)
• >-<+vv được thay thế bằng +>-<vv

Làm hỏng

Thực hiện bất thường # 3 làm cho mọi thứ khá tầm thường.

_{* Nó không phải là một lỗi, đó là một tính năng!}

Brainfuck, 579 byte

,[<<+>>>>+<<[[<+>>+<-]++++++[>-------<-]>-[-[-[-[--------------[--[<+++++[>-----
-<-]>+[--[<<[-]>>-]]<]>[>>-<<<<<[-]<[<]<<<[<]>>>>>>>>[<]<-[+>]+[->+]>>>>+>[<-]<[
>+<-<]>]<]>[<<<[-]-[<]>>>>>>>>>>>[<]<<<<<<[<]<-[+>]+[-<+]<<<+<[>-<<<]>[-<+<]]]<]
>[+>[-<]<[<<]<[-]>>]]<]+>[-[<-]<[>+>+<<-<]<[-]>+>]<<[>-]>[,>]<]<+<[>]>[>>>[<<<<[
-<]<<<]>>>+>>>>[<<<<->>>>[>>>[-<]>>>>]]]>[<<<[<+[-->>]]>[-[.[-]]]>[<]>[<<++++++[
>+++++++<-]>+>>[<<.>>-]<<++>-[<.>-]+++[<+++++>-]+<<<<<<+>[<<[>->>>>>.[[-]<<<<]<<
<+>>>]>[->->>>>[-]]]<[->+[>>>>>]>>[<]<<<<<<<<[[-]<]>[++.[-]>>>>>>>]<]]>>]<[>>>>>
>>]+[-<<<<<[-]<<],]

Với định dạng và một số ý kiến:

,
[
  <<+>> >>+<<
  [
    [<+> >+<-]
    ++++++[>-------<-]
    >-
    [
      not plus
      -
      [
        not comma
        -
        [
          not minus
          -
          [
            not period
            --------------
            [
              not less than
              --
              [
                not greater than
                <+++++[>------<-]>+
                [
                  not open bracket
                  --
                  [
                    not close bracket
                    <<[-]>>-
                  ]
                ]
                <
              ]
              >
              [
                greater than
                >>-<<
                <<<[-]<[<]<<<[<]
                >>>>>>>>[<]
                <-[+>]
                +[->+]
                >>>>+>[<-]
                <[>+<-<]
                >
              ]
              <
            ]
            >
            [
              less than
              <<<[-]-[<]
              >>>> >>>>>>>[<]
              <<<<<<[<]
              <-[+>]
              +[-<+]
              <<<+<[>-<<<]
              >[-<+<]
            ]
          ]
          <
        ]
        >
        [
          minus
          +>[-<]
          <[<<]
          <[-]>>
        ]
      ]
      <
    ]
    +>
    [
      plus
      -[<-]
      <[>+>+<<-<]
      <[-]>+>
    ]
    <<
    [
      comma or period or bracket
      >-
    ]
    >[,>]
    <
  ]
  comma or period or bracket or eof
  <+<
  [
    start and end same cell
    >
  ]
  >
  [
    >>>
    [
      <<<<[-<]<<<
    ]
    >>>+>>>>
    [
      start right of end
      <<<<->>>>
      [>>>[-<]>>>>]
    ]
  ]
  >
  [
    <<<
    [
      <+[-->>]
    ]
    >[-[.[-]]]
    >[<]
    >
    [
      <<++++++[>+++++++<-]>+>>
      [<<.>>-]
      <<++>-[<.>-]
      +++[<+++++>-]
      +<<<<< <+>
      [
        <<
        [
          go left
          >->>>>>.
          [[-]<<<<]
          <<<+>>>
        ]
        >
        [
          toggle left right
          ->->>>>[-]
        ]
      ]
      <
      [
        toggle right left
        ->+[>>>>>]>>[<]
        <<<<<<<<
        [
          [-]<
        ]
        >
        [
          go right
          ++.[-]
          >>>>>>>
        ]
        <
      ]
    ]
    >>
  ]
  <[>>>>>>>]
  +[-<<<<<[-]<<]
  ,
]

Điều này sử dụng phương pháp tương tự như giải pháp của Keith Randall, giảm thiểu tất cả các chuỗi liên tục +-<>tối ưu bằng mô phỏng. Chẳng hạn, +++>-<+>---<trở thành ++++>----<và >+<+<<+>+<->>>>trở thành +<+>>+>.

Hãy thử trực tuyến. (Nếu giá trị tuyệt đối của một ô được mô phỏng đạt gần 256, sẽ có vấn đề tràn.)

Cấu trúc tổng thể là

while not EOF:
  while not EOF and next char not in ",.[]":
    process char
  print minified sequence (followed by the char in ",.[]" if applicable)

Băng được chia thành các nút 7 ô; ở đầu vòng lặp bên trong, bố trí bộ nhớ là

0 s 0 c 0 a b

trong đó smột cờ boolean cho ô bắt đầu, clà ký tự hiện tại, alà phần âm của giá trị ô mô phỏng (cộng với một) và blà phần dương của giá trị ô mô phỏng.

Khi trình tự rút gọn đang được in, bố trí bộ nhớ là

d n e 0 0 a b

trong đó dmột cờ boolean cho hướng avà bgiống như trước (nhưng trở thành một / không khi được in) nvà echỉ khác không cho nút kết thúc; ncó liên quan đến số lần nút được nhìn thấy và elà giá trị của char tạm dừng vòng lặp bên trong (cộng với một).

Ban đầu tôi coi việc theo dõi nhiều thông tin hơn trên mỗi nút: nút ngoài cùng bên phải và dưới dạng cờ boolean và vị trí của nút liên quan đến các nút bắt đầu và kết thúc. Nhưng chúng ta có thể tránh điều đó bằng cách nhìn vào các ô lân cận khi cần và bằng cách quét trái và phải để tìm nút bắt đầu.

Khi in trình tự rút gọn và quyết định cách di chuyển con trỏ mô phỏng, chúng ta có thể thực hiện một cách tiếp cận chung: bắt đầu bằng cách di chuyển khỏi nút kết thúc (theo hướng tùy ý nếu các nút bắt đầu và kết thúc giống nhau), xoay quanh ở ngoài cùng và bên phải các nút và dừng dựa trên số lần nút kết thúc đã được nhìn thấy: 3 lần nếu các nút bắt đầu và kết thúc giống nhau, nếu không thì 2.

Python, ký tự 404

Mã này thực hiện tối ưu hóa hoàn hảo tất cả các phần sau của +-<>. Một chút nhiều hơn bạn yêu cầu, nhưng có bạn đi.

M=lambda n:'+'*n+'-'*-n                                                           
def S(b):                                                                         
 s=p=0;t=[0];G,L='><'                                                             
 for c in b:                                                                      
  if'+'==c:t[p]+=1                                                                
  if'-'==c:t[p]-=1                                                                
  if G==c:p+=1;t+=[0]                                                             
  if L==c:s+=1;t=[0]+t                                                            
 if p<s:k=len(t)-1;t,p,s,G,L=t[::-1],k-p,k-s,L,G                                  
 r=[i for i,n in enumerate(t)if n]+[s,p];a,b=min(r),max(r);return(s-a)*L+''.join(M(n)+G for n in t[a:b])+M(t[b])+(b-p)*L                                           
s=b=''                                                                            
for c in raw_input():                                                             
 if c in'[].,':s+=S(b)+c;b=''                                                     
 else:b+=c                                                                        
print s+S(b) 

Nó hoạt động bằng cách mô phỏng các +-<>hoạt động trên băng t. slà vị trí bắt đầu trên băng và plà vị trí hiện tại. Sau khi mô phỏng, nó chỉ ra mức độ [a,b]cần phải được vận hành và thực hiện tất cả +/- trong một lần tối ưu.

Cà phê - 403 397

i=prompt().replace /[^\]\[,.+-><]/g,''
x=(c)->
 t={};p=n=0
 for d in c
  t[p]?=0;switch d
   when'+'then n=1;t[p]++;when'-'then n=1;t[p]--;when'<'then p--;when'>'then p++
 (n=0if v!=0)for k,v of t;n
s=e=0;((e++;(i=(i.substr 0,s)+i.substr e;e=s=0)if x (i.substr s,e-s).split "")while(i[e]||0)!in['[',']',0];e=++s)while s<=i.length
r=/(\+-|-\+|<>|><|^[<>]$)/g
i=i.replace r,'' while r.test i
alert i

Bản demo (xin vui lòng tha thứ cho việc sử dụng bit.ly tại đây, toàn bộ URL sẽ phá vỡ đánh dấu)

Phiên bản không nén (mã w / gỡ lỗi):

console.clear()
input = """Should disappear: ++>>+<+++<->-->-<<->-<
Should disappear: +++>-<--->+<
Should stay: +++>-<+>---<"""

input = input.replace /[^\]\[,.+-><]/g, ''
console.log input

execute = (code) ->
  stack = {}
  item = 0
  console.log code
  nop = false
  for char in code
    switch char
      when '+' then nop = true; stack[item]?=0;stack[item]++
      when '-' then nop = true; stack[item]?=0;stack[item]--
      when '<' then item--
      when '>' then item++
  console.debug stack
  (nop = false if v != 0) for k,v of stack
  nop
start = 0
end = 0

while start <= input.length
 while input.charAt(end) not in [ '[', ']', '' ]
  end++
  if execute (input.substring start, end).split("")
    input = (input.substring 0, start) + input.substring end
    end = start = 0
    console.log input
 end = ++start
input = input.replace /(\+-|-\+|<>|><|^(<|>)$)/g, '' while /(\+-|-\+|<>|><)/.test input
console.log 'Result: ' + input