Դիտել Մասնակից:Fperson/Ավազարկղ1 էջի աղբյուրը

Ձեզ չի թույլատրվում խմբագրել այս էջը հետևյալ պատճառով.

Your IP address is in a range that has been blocked on all Wikimedia Foundation wikis.

The block was made by ‪EPIC‬. The reason given is Open proxy/Webhost: See the help page if you are affected.

Start of block: 08:48, 2 Հուլիսի 2024
Expiry of block: 08:48, 2 Հուլիսի 2025

Your current IP address is 206.189.44.186. The blocked range is 206.189.32.0/20.

Please include all above details in any queries you make. If you believe you were blocked by mistake, you can find additional information and instructions in the No open proxies global policy.

Otherwise, to discuss the block please post a request for review on Meta-Wiki. You could also send an email to the stewards VRT queue at stewards@wikimedia.org including all above details.

Դուք կարող եք դիտել և պատճենել այս էջի ելատեքստը.

'''Brainfuck,''' 1993 թվականին Ուրբան Մյուլերի ({{lang-de|Urban Müller}}) կողմից ստեղծված ամենահայտնի էզոտերիկ ծրագրաբորման լեզուներից մեկը, որը հայտնի է իր մինիմալիզմով: Լեզվի անվանումը հայերեն կարելի է թարգմանել՝ որպես ''ուղեղի բռնաբարում'', ինչը ուղղակիորեն ծագել է անգլերեն ''brainfuck'' (''brain''՝ ուղեղ, ''fuck՝'' ''սեռական հարաբերություն ունենալ'') արտահայտությունից, այսինքն՝ ''անհեթեթությամբ զբաղվել'': Լեզուն ունի ութ հրաման, որոնցից յուրաքանչյուրը գրառվում է մեկ սիմվոլով: Brainfuck-ի ելքային կոդը իրենից ներկայացնում է այդ սիմվոլների հերթականությունը՝ առանց որևէ լրացուցիչ շարահյուսության։

Ուրբան Մյուլերի հիմնական դրդապատճառներից մեկը եղել է հնարավորինս փոքր կոմպիլյատորով ծրագրավորման լեզվի ստեղծումը։ Մասամբ նա ոգեշնչված է եղել [[FALSE]] ծրագրավորման լեզվով, որի համար գոյություն ուներ 1024 բայթ չափսով կոմպիլյատոր։ Brainfuck-ի համար գոյություն ունեն 200 բայթից ավելի քիչ չափսով կոմպիլյատորներ<ref>Например, {{cite web|url=http://www.muppetlabs.com/~breadbox/software/tiny/bf.asm.txt|title=исходник компилятора размером 166 байт|accessdate=2010-08-18|archiveurl=http://www.webcitation.org/61C8iHPxq?url=http://www.muppetlabs.com/~breadbox/software/tiny/bf.asm.txt|archivedate=2011-08-25|deadurl=yes}}</ref>։ Brainfuck լեզվով դժվար է ծրագրեր գրել, ինչի համար երբեմն այն անվանում են մազոխիստների լեզու։ Միևնույն ժամանակ պետք է նշել, որ Brainfuck-ը բոլորովին բնական, լիակատար ու հասարակ լեզու է և կարող է օգտագործվել հաշվարկվածության հասկացության սահնանման համար։

Մեքենան, որը կառավարում են Brainfuck-ի հրամանները, բաղկացած է [[Թյուրինգի մեքենա|Թյուրինգի մեքենայի]] ժապավենն ու գլխիկը հիշեցնող բջիջների կարգավորված հավաքածույից և տվյալ բջջի ցուցիչից: Բացի այդ, ենթադրվում է ներմուծման և արտածման հոսքերի միջոցով արտաքին աշխարհի հետ շփման սարք: 

Brainfuck լեզուն կարելի է նկարագրել [[C]] լեզվի համարժեքների միջոցով՝
{|class="wikitable"
! Brainfuck-ի հրաման
! C-ի համարժեք
! Հրամանի նկարագրում
|-
|style="text-align:center"|Ծրագրի սկիզբ||<code>int i = 0;<br>char arr[30000];<br>memset(arr, 0, sizeof(arr));</code> || выделяется память под 30 000 ячеек с нулевыми начальными значениями
|-
|style="text-align:center"|<code>></code> || <code>i++;</code> || անցնել հաջորդ բջջին
|-
|style="text-align:center"|<code><</code> || <code>i--;</code> || անցնել նախորդ բջջին
|-
|style="text-align:center"|<code>+</code> || <code>arr[i]++;</code> || տվյալ բջջի արժեքը ավելացնել մեկով
|-
|style="text-align:center"|<code>-</code> || <code>arr[i]--;</code> || տվյալ բջջի արժեքը նվազեցնել մեկով
|-
|style="text-align:center"|<code>.</code> || <code>putchar(arr[i]);</code> || տպել տվյալ բջջի արժեքը
|-
|style="text-align:center"|<code>,</code> || <code>arr[i]&nbsp;=&nbsp;getchar();</code> || ввести извне значение и сохранить в текущей ячейке
|-
|style="text-align:center"|<code>[</code> || <code>while(arr[i]){</code> || если значение текущей ячейки ноль, перейти вперёд по тексту программы на ячейку, следующую за соответствующей <tt>]</tt> (с учётом вложенности)
|-
|style="text-align:center"|<code>]</code> || <code>}</code> || если значение текущей ячейки не нуль, перейти назад по тексту программы на символ <tt>[</tt> (с учётом вложенности)
|}

Չնայած արտաքին պարզությանը՝ բջիջների անսահման թվով Brainfuck-ը ունի Թյուրինգի լիություն, հետևաբար՝  Несмотря на внешнюю примитивность, ''Brainfuck'' с бесконечным набором ячеек имеет [[Полнота по Тьюрингу|тьюринговскую полноту]], а, следовательно, по потенциальным возможностям не уступает «настоящим» языкам, подобным [[Си (язык программирования)|Си]], [[Паскаль (язык программирования)|Паскалю]] или [[Java]].

''Brainfuck'' подходит для экспериментов по [[Генетическое программирование|генетическому программированию]] из-за простоты синтаксиса, и, соответственно, генерации исходного кода.

В «классическом» ''Brainfuck'', описанном Мюллером, размер ячейки — один байт, количество ячеек 30 000. В начальном состоянии указатель находится в крайней левой позиции, а все ячейки заполнены нулями. Увеличение/уменьшение значений ячеек происходит по модулю 256. Ввод-вывод также происходит побайтно, с учётом кодировки ASCII (то есть в результате операции ввода (''',''') символ '''''1''''' будет записан в текущую ячейку как число 0x31 (49), а операция вывода ('''.'''), совершённая над ячейкой, содержащей 0x41 (65), напечатает латинскую '''''А'''''). В других вариантах языка размер и количество ячеек может быть другим (бо́льшим). Есть версии, где значение ячеек не целочисленно (с плавающей точкой).

== Ծրագրի օրինակ ==
: Brainfuck֊ով գրված ծրագիր, որն արտածում է «''Hello World!''»՝
<source lang="bf">
 ++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++
 .>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.
 ------.--------.>+.>.
</source>

Разбор программы:
{{-}}
{|frame
 |colspan=3 | Подготовка в памяти (с ячейки 1) массива значений, близких к ASCII-кодам символов, которые необходимо вывести (70, 100, 30, 10), через повторение 10 раз приращения ячеек на 7, 10, 3 и 1, соответственно
 |-
 | width=10|  || '''<code>++++++++++</code>''' || присваивание ячейке 0 (счетчику) значения 10
 |-
 | || '''<code>[</code>''' || повторять, пока значение текущей ячейки (ячейки 0) больше нуля
 |-
 | || '''<code>>+++++++</code>''' || приращение ячейки 1 на 7
 |-
 | || '''<code>>++++++++++</code>''' || приращение ячейки 2 на 10
 |-
 | || '''<code>>+++</code>''' || приращение ячейки 3 на 3
 |-
 | || '''<code>>+</code>''' || приращение ячейки 4 на 1
 |-
 | || '''<code><<<<-</code>''' || возврат к ячейке 0 (счетчику), и его уменьшение на 1
 |-
 | || '''<code>]</code>''' || вернуться к началу цикла
 |-
 |colspan=3 | Տառերի կոդերի ստացում և դրանց արտածում
 |-
 | || '''<code>>++.</code>''' || Вывод «''Н''». Получение кода «H» (72) из 70 в ячейке 1 и вывод
 |-
 | || '''<code>>+.</code>''' || Вывод «''e''». Получение кода «e» (101) из 100 в ячейке 2 и вывод
 |-
 | || '''<code>+++++++..</code>''' || Вывод «''ll''». Получение кода «l» (108) из 101 в ячейке 2 и вывод дважды
 |-
 | || '''<code>+++.</code>''' || Вывод «''o''». Получение кода «o» (111) из 108 в ячейке 2 и вывод
 |-
 | || '''<code>>++.</code>''' || Вывод пробела. Получение кода пробела (32) из 30 в ячейке 3 и вывод
 |-
 | || '''<code><<+++++++++++++++.</code>''' || Вывод «''W''». Получение кода «W» (87) из 72 в ячейке 1 и вывод
 |-
 | || '''<code>>.</code>''' || Вывод «''o''». Код «o» (111) уже находится в ячейке 2, просто его выводим
 |-
 | || '''<code>+++.</code>''' || Вывод «''r''». Получение кода «r» (114) из 111 в ячейке 2 и вывод
 |-
 | || '''<code>------.</code>''' || Вывод «''l''». Получение кода «l» (108) из 114 в ячейке 2 и вывод
 |-
 | || '''<code>--------.</code>''' || Вывод «''d''». Получение кода «d» (100) из 108 в ячейке 2 и вывод
 |-
 | || '''<code>>+.</code>''' || Вывод «''!''». Получение кода «!» (33) из 32 в ячейке 3 и вывод
 |-
 | || '''<code>>.</code>''' || Вывод кода перевода строки (10) из ячейки 4
|}
В принципе, печать «Hello World!» можно реализовать проще, но программа будет в три с лишним раза больше, чем приведённый выше оптимизированный вариант:
<source lang="bf">
 +++++++++++++++++++++++++++++++++++++++++++++
 +++++++++++++++++++++++++++.+++++++++++++++++
 ++++++++++++.+++++++..+++.-------------------
 ---------------------------------------------
 ---------------.+++++++++++++++++++++++++++++
 ++++++++++++++++++++++++++.++++++++++++++++++
 ++++++.+++.------.--------.------------------
 ---------------------------------------------
 ----.-----------------------.</source>

== Brainfuck֊ի ինտերպրետատոր ==
Пример интерпретатора Brainfuck, написанный на языке Perl
<source lang="perl">
#!/usr/bin/perl
open F, shift;
@code = grep {/[+-\.,\[\]><]/} split '', <F>;
for (my $_ = 0; $_ < @code; ++$_) {
  ++$cpu[$i] if $code[$_] eq '+';
  --$cpu[$i] if $code[$_] eq '-';
  --$i if $code[$_] eq '<';
  ++$i if $code[$_] eq '>';
  print chr $cpu[$i] if $code[$_] eq '.';
  $cpu[$i] = ord <STDIN> if $code[$_] eq ',';
  if ($code[$_] eq '[') {
    if (!$cpu[$i]) {
      ++$brc;
      while ($brc) {
        ++$_;
        ++$brc if $code[$_] eq '[';
        --$brc if $code[$_] eq ']';
      }
    } else {
      next;
    }
  } elsif ($code[$_] eq ']') {
    if (!$cpu[$i]) {
      next;
    } else {
      ++$brc if $code[$_] eq ']';
      while ($brc) {
        --$_;
        --$brc if $code[$_] eq '[';
        ++$brc if $code[$_] eq ']';
      }
    --$_;
    }
  }
}
</source>

Пример интерпретатора Brainfuck, написанный на языке C++
<source lang="cpp">
#include <iostream>
#include <fstream>
#include <vector>

using namespace std;

static char cpu[30000];

int main(int argc, char **argv) {
    vector<char> acc;
    char ch;
    ifstream infile(argv[1]);
    while (infile) {
        infile.get(ch);
        acc.push_back(ch);
    }
    infile.close();
    unsigned int j = 0;
    int brc = 0;
    for (int i = 0; i < acc.size(); ++i) {
        if (acc[i] == '>')
            j++;
        if (acc[i] == '<')
            j--;
        if (acc[i] == '+')
            cpu[j]++;
        if (acc[i] == '-')
            cpu[j]--;
        if (acc[i] == '.')
            cout << cpu[j];
        if (acc[i] == ',')
            cin >> cpu[j];
        if (acc[i] == '[') {
            if (!cpu[j]) {
                ++brc;
                while (brc) {
                    ++i;
                    if (acc[i] == '[')
                        ++brc;
                    if (acc[i] == ']')
                        --brc;
                }
            } else
                continue;
        } else if (acc[i] == ']') {
            if (!cpu[j])
                continue;
            else {
                if (acc[i] == ']')
                    brc++;
                while (brc) {
                    --i;
                    if (acc[i] == '[')
                        brc--;
                    if (acc[i] == ']')
                        brc++;
                }
                --i;
            }
        }
    }
}
</source>

== Программирование на языке Brainfuck ==
Каждый начинающий программировать на ''Brainfuck'' немедленно сталкивается со следующими проблемами:
* отсутствие операции копирования значения
* отсутствие промежуточной (''аккумуляторной'') памяти
* отсутствие [[условный оператор|условных операторов]] в их привычном виде
* отсутствие привычной [[арифметика|арифметики]], операций [[умножение|умножения]] и [[Деление (математика)|деления]]
Эти проблемы могут быть решены.

<!--
{|
 |colspan=3| '''Обозначения:'''
 |-
 |-
 | width=20| || '''p''' || адрес текущей ячейки (переменная макрокомпилятора)
 |-
 | || '''a<sub>i</sub>''' || адреса ячеек
 |-
 | || '''t<sub>i</sub>''', '''x<sub>i</sub>''' || адреса вспомогательных ячеек (значение которых не ценно)
 |-
 | || '''n<sub>i</sub>''' || константы
 |-
 | || colspan=2| в комментариях p,a<sub>i</sub>, t<sub>i</sub>, x<sub>i</sub> выражает значение по адресу p,a<sub>i</sub>, t<sub>i</sub>, x<sub>i</sub>
 |-
 | || '''bf<sub>i</sub>''' || bf-строки
 |-
 | || '''#bf''' || вывод в текущую bf-программу строки bf
 |-
 | || '''#(bf,n)''' || вывод в текущую bf-программу строки bf n раз
 |-
 | || '''"chars"''' ||  вывод в текущую bf-программу символов внутри кавычек
 |-
 | || '''{ }''' || группировка
 |-
 | || '''--''' || всё, правее этого символа — комментарий
 |-
 | || '''==''' || далее этого символа идёт строгое определение
 |}

--------------------------------------------------------------------------------
move и goto

move(n) — сдвинуться на n адресов
        ==
        если n > 0  то #( '>', n)
        если n < 0  то #( '<', n)

goto(a) — перейти к адресу a (от текущего адреса p)
        == move( a-p ); p := a;

Далее будем обозначать:
        @a == goto(a) 
--------------------------------------------------------------------------------
нуль-адресные zero, inc, dec, addC, subC, setC, inp, out:

zero() — p := 0
        == "[-]"

inc() — p++
        == "+"

dec() — p--
        == "-"

addC(n) — p += n
        == 
                если n > 0  то #( '+', n)
                если n < 0  то #( '-', n)

subC(n) — p -= n
        == 
                если n > 0  то #( '-', n)
                если n < 0  то #( '+', n)

setC(n) — p := n
        == zero(); addC(n)

inp() == ", "

out() == «.»

--------------------------------------------------------------------------------
одноадресные zero, inc, dec, addC, subC, setC, inp, out:

zero(a) — a := 0
        == @a zero()

inc(a) — a++
        == @a inc()

dec(a) — a--
        == @a dec();

addC(a, n) — a += n
        == @a addC(n)

subC(a, n) — a -= n
        == @a subC(n)

setC(a, n) — a := n
        == zero(a) addC(n)

inp(a) == @a inp()

out(a) == @a out()

--------------------------------------------------------------------------------
двухадресные add, sub, set:

add(a1,a2) — a1 += a2; a2 := 0
        == @a2 "[" @a1 "+" @a2 "-]"

sub(a1,a2) — a1 -= a2; @a2 := 0
        == @a2 "[" @a1 "-" @a2 "-]"

set(a1,a2) — a1 := a2; a2 := 0;
        == zero(a1) add(a1,a2)

--------------------------------------------------------------------------------
многоадресные add, sub, set с сохранением:

add(a1,a2,x) — a1 += a2; x := 0
        ==  zero(x) @a2 "[" inc(a1) inc(x) dec(a2) "]" set(a2,x)

sub(a1,a2,x) — a1 -= a2; x := 0
        ==  zero(x) @a2 "[" dec(a1) inc(x) dec(a2) "]" set(a2,x)

set(a1,a2,x) — a1 := a2; x := 0
        ==  zero(a1) add(a1,a2,x)

--------------------------------------------------------------------------------
циклы и условия:

loop(a, bf)
        == @a "[" #bf  @a "]"

loopFor(a, bf) — выполнить bf a раз; a := 0
        == loop( a, { #bf dec(a) } )

loopFor(a, bf, x) — выполнить bf a раз, сохранив a
        == zero(x) loop( a, { #bf inc(x) dec(a) } ) set(a,x)

if(a, bf) — выполнить bf, если a!=0; a := 0
        == loop( a, { #bf zero(a) } )

if(a, bf, x1,x2) — выполнить bf, если a!=0, сохранив a
        == set(x1,a,x2) if(x1,bf)

ifelse(a, bf1,bf2,x) — выполнить bf1, если a!=0; a := 0
        == setC(x,1)  if( a, { #(bf1) dec(x) } )   if(x,bf2)

ifelse(a, bf1,bf2,x1,x2) — выполнить bf1, если a!=0, сохранив a
        == set(x1,a,x2)  inc(x2)  if( x1, { #bf1 dec(x2) } )  if(x2,bf2)

--------------------------------------------------------------------------------
умножение:

mul(a1,a2,x1,x)
        -- a1 *= a2; a2 := 0
        == set(x1,a1,x)  dec(a2)  loopFor( a2, { add(a1,x1,x) } )

mul(a1,a2,x1,x2,x)
        -- a1 *= a2 с сохранением a1 и a2
        == set(x1,a1,x) set(x2,a2,x) dec(x2) loopFor( x2, { add(a1,x1,x) } )

mulN(a, n, x1, x2)
        -- a *= n
        := set(x1,a,x2)  loopFor( x1, { @a #('+', n-1) } )

--------------------------------------------------------------------------------
более сложный пример:

getNumberUptoSpace(a, t,x, x1,x2)
        -- считывает символы, интерпретируя их как десятичное число (до пробела)
        -- и сохраняет в a

        ==

                zero(a)
                setC(t,1)
                loop(t,
                { dec(t) inp(x) sub(x,10)
                  if( x,
                  {
                    subC(x,22);
                    if( x,
                    {
                       subC(x,16)  mulN(a,10,x1,x2)  add(a,x)  inc(t)
                    })
                  })
                })

-->
  Обозначим через '''''@(k)''''' сдвиг на k ячеек вправо, если k>0, и влево, если k<0
  Соответственно, @(k) = >…<sub>k раз</sub>…> либо <…<sub>-k раз</sub>…<  <br>
  '''''zero():''''' обнуление текущей ячейки:
    [-]
    =
    [+]<br>
  '''''add(k):''''' прибавление значения ячейки n (текущей) к значению ячейки n+k:
     [ — @(k)  + @(-k)  ]
  при этом значение ячейки n теряется (обнуляется).<br>
  '''''mov(k):''''' копирование значения ячейки n (текущей) в ячейку n+k с потерей (обнулением) значения ячейки n:
    @(k) zero() @(-k) add(k)
    =
    @(k) [-] @(-k) [ — @(k)  + @(-k)  ] <br>
  '''''copy(k,t):''''' копирование значения ячейки n (текущей) в ячейку n+k 
  c использованием промежуточной ячейки n+k+t, благодаря чему значение ячейки n не теряется (сохраняется).
    @(k) zero() @(t) zero() @(-k-t) [ — @(k) + @(t) + @(-k-t) ] @(k+t) mov(-k-t)
    =
    @(k) [-] @(t) [-] @(-k-t) [ — @(k) + @(t) + @(-k-t) ] @(k+t) [ — @(-k-t) + @(k+t) ]<br>
  '''''ifelse(t):''''' если текущая ячейка>0, то выполняется условие true
             если текущая ячейка=0, то выполняется условие false
             t-относительный номер вспомогательной ячейки:
    @(t)[-]+@(-t) устанавливаем флаг 1 для случая else
    [
     здесь действия ветки true
     @(t)[-]@(-t) устанавливаем флаг 0 для случая else
     [-] выход из цикла
 ]
    @(t)
    [@(-t)
     здесь действия ветки false
     @(t)[-] выход из цикла
 ]
    @(-t-1)

''Brainfuck'' почти не используется для практического программирования (за исключением работ отдельных энтузиастов), а используется преимущественно для головоломок и задач для соревнований.
<!--
План дальнейшего развития статьи:
— перспективы использования BF (для реальных задач — нет, для обучения — да)
— приёмы программирования на BF (обнуление, копирование, сложение-вычитыние, условие, цикл, умножение-деление)
— приёмы оптимизация BF-программ
— языки на основе BF
-->

== Brainfuck֊ի հիման վրա ստեղծված լեզուներ ==
{| class="wikitable"
|{{highlight1}} |Ook!
|{{highlight1}} |COW
|{{highlight1}} |Brainfuck
|{{highlight1}} |Описание
|-
|Ook. Ook. ||MoO ||+||Значение текущей ячейки увеличивает на 1
|-
|Ook! Ook! ||MOo ||-||Значение текущей ячейки уменьшают на 1
|-
|Ook. Ook? ||moO ||>||Следующая ячейка
|-
|Ook? Ook. ||mOo ||<||Предыдущая ячейка
|-
|Ook! Ook? ||moo ||[||Начало цикла
|-
|Ook? Ook! ||MOO ||]||Конец цикла
|-
|Ook! Ook. ||OOM ||.||Вывод значения текущей ячейки
|-
|Ook. Ook! ||oom ||,||Запрос значения текущей ячейки
|-
| ||mOO||''отсутствует''||Выполняет инструкцию с номером, который берётся из текущей ячейки (если значение в текущей ячейке равно 3, то это приводит к бесконечному циклу).
|-
| ||Moo||''отсутствует''||Если значение текущей ячейки равно нулю, то ввести его с клавиатуры; если же значение текущей ячейки — не ноль, то вывести его на экран.
|-
| ||OOO||[-]||Обнуляет значение в текущей ячейке
|-
| ||MMM||''отсутствует''||
|}

== Տես նաև ==
* [[Тьюринговская трясина]]

=== Диалекты и реализации ===
* [[Spoon]]
* [[LOLCODE]]
* [[Whitespace]]
* [[Feckfeck]]
Ещё описание множества диалектов этого языка можно найти в вики-энциклопедии эзотерических языков<ref>[http://esolangs.org/wiki/Category:Brainfuck_derivatives Category:Brainfuck_derivatives], esolangs.org</ref>

== Ծանոթաագրություններ==
{{ծանցանկ}}

== Արտաքին հղումներ ==
* [http://bf-fan.coolpage.biz/ Немного о brainfuck на русском языке и пара инструментов для работы с ним]
* [http://www.muppetlabs.com/~breadbox/bf Оригинальное описание BF на английском языке и ссылки на BF-ресурсы]
* [http://www.4mhz.de/ Brainfuck interpreter with integrated debugger (IDE) for Windows]
* {{lj comm|ru_brainfucker}} — русское ЖЖ-сообщество любителей эзотерических языков
* [http://rsdn.ru/article/philosophy/languages.xml статья на rsdn.ru об эзотерических языках программирования]
* [http://bolknote.ru/files/bf/ Processing_BF] — оптимизирующий интерпретатор и транслятор в [[PHP]], написанный на языке [[PHP]]
* [http://bfinterpreter.narod.ru/ BrainfuckInterpreter] — кроссплатформенный оптимизирующий интерпретатор на [[Java]], переехал на [http://bfrun.berlios.de/ Brainfuck Interpreter bfrun]
* [http://esco.sourceforge.net/ esco — универсальный интерпретатор эзотерических языков]
* [http://brainfuck.progopedia.ru/ Интерпретатор brainfuck на JavaScript с открытым исходным кодом]
* [http://procool.ru/brainfuck/ Переводчик с brainfuck на Perl и обратно с открытым исходным кодом]
* [http://bobiczdoh.jino-net.ru/?area=download Интерпретатор brainfuck с открытым исходным кодом]
* [http://habrahabr.ru/sandbox/32031/ Статья о создании транслятора brainfuck в C]
* [http://esoteric.sange.fi/brainfuck/ The Brainfuck Archive]
* [http://esolangs.org/wiki/Brainfuck Brainfuck] on the [http://esolangs.org/wiki/Main_Page Esolang (Esoteric Languages) wiki]
* [https://sites.google.com/site/visualbf Visual brainfuck], a brainfuck IDE compatible with Windows 7 x86 and x64.
* [http://4mhz.de/bfdev.html Brainfuck Developer], Brainfuck IDE for Windows (also works with WINE under Linux)
* {{dmoz|Computers/Programming/Languages/Brainfuck}}
* [http://code.google.com/p/junkdrawer/downloads/ bf2c], a Brainfuck to C translator.
* [http://rubygems.org/gems/ookie ookie], a Brainfuck and Ook! language interpreter
* [http://code.google.com/p/esoteric-lingo/downloads/list Ook.jar], another Ook! and Brainfuck language interpreter, this time written in Java.
* [http://www.beco.cc/compiler/brainforce/brainforce.html BrainForce], compiler (wrap gcc) and C translator (has lots of options to control wrapping values, cell sizes, etc.)
* [http://www.davenicholas.me.uk/blog/view_post/31/esolang-esoteric-programming-for-iphone esolang], a Brainfuck interpreter for iPhone written in objective c.
* [http://copy.freeunix.net/brainfuck/ Le Brainfuck], a Javascript based optimizing interpreter. Also has many options, including memory dumping.
* [https://www.github.com/FabianM/Brainfuck Brainfuck C], a lightweight Brainfuck interpreter written in C.
* [https://www.github.com/FabianM/Brainfuck-Java Brainfuck Java], an interpreter for the Brainfuck language and its dialects written in the Java programming language.
* [http://computacion.cs.cinvestav.mx/~mruiz/cursos/maestria/cspl.html lex/yacc-based Brainfuck interpreter in C and Python]
* [https://github.com/cyberpython/Bfck Bfck], open-source Brainfuck interpreter written in C.

{{Ծրագրավորման լեզուներ}}

Այս էջում օգտագործված կաղապարները.

Կաղապար:* (դիտել ելատեքստը) (կիսա-պաշտպանված է)
Կաղապար:- (խմբագրել)
Կաղապար:Cite web (խմբագրել)
Կաղապար:Dmoz (խմբագրել)
Կաղապար:Highlight1 (խմբագրել)
Կաղապար:Lang-de (խմբագրել)
Կաղապար:Lj comm (խմբագրել)
Կաղապար:Main other (խմբագրել)
Կաղապար:Navbox (խմբագրել)
Կաղապար:Nobr (խմբագրել)
Կաղապար:Nowrap (խմբագրել)
Կաղապար:Ազատ (խմբագրել)
Կաղապար:Ծանցանկ (դիտել ելատեքստը) (կիսա-պաշտպանված է)
Կաղապար:Ծանցանկ/styles.css (խմբագրել)
Կաղապար:Ծրագրավորման լեզու (խմբագրել)
Կաղապար:Ծրագրավորման լեզուներ (խմբագրել)
Կաղապար:Կատեգորիան միայն հոդվածներում (խմբագրել)
Կաղապար:Տեղեկաաղյուսակ (խմբագրել)
Կաղապար:• (դիտել ելատեքստը) (պաշտպանված է)
Մոդուլ:Arguments (դիտել ելատեքստը) (կիսա-պաշտպանված է)
Մոդուլ:Check for unknown parameters (խմբագրել)
Մոդուլ:Citation/CS1 (դիտել ելատեքստը) (կիսա-պաշտպանված է)
Մոդուլ:Citation/CS1/COinS (խմբագրել)
Մոդուլ:Citation/CS1/Configuration (խմբագրել)
Մոդուլ:Citation/CS1/Date validation (խմբագրել)
Մոդուլ:Citation/CS1/Identifiers (խմբագրել)
Մոդուլ:Citation/CS1/Suggestions (խմբագրել)
Մոդուլ:Citation/CS1/Utilities (խմբագրել)
Մոդուլ:Citation/CS1/Whitelist (խմբագրել)
Մոդուլ:Citation/CS1/styles.css (խմբագրել)
Մոդուլ:Navbar (դիտել ելատեքստը) (կիսա-պաշտպանված է)
Մոդուլ:Navbox (խմբագրել)
Մոդուլ:Կատեգորիաները միայն հոդվածում (խմբագրել)

Վերադարձ դեպի Մասնակից:Fperson/Ավազարկղ1։

Ստացված է «https://hy.wikipedia.org/wiki/Մասնակից:Fperson/Ավազարկղ1» էջից