ব্রেইনফের ব্যাখ্যা

113

ব্রেইনফাক প্রোগ্রামটি ব্যাখ্যা করতে আপনার পছন্দের ভাষায় সবচেয়ে সংক্ষিপ্ত প্রোগ্রামটি লিখুন । প্রোগ্রামটি একটি ফাইল থেকে পড়া হয়। ইনপুট এবং আউটপুট মান ইনপুট এবং মান আউটপুট।

  1. কক্ষের আকার: 8 বিট স্বাক্ষরযুক্ত ওভারফ্লো অনির্ধারিত।
  2. অ্যারের আকার: 30000 বাইট (বৃত্তাকার নয়)
  3. খারাপ আদেশগুলি ইনপুটটির অংশ নয়
  4. মন্তব্যগুলি # দিয়ে শুরু হয় এবং লাইনের শেষ পর্যন্ত প্রসারিত হয় মন্তব্যগুলি সব কিছু না+-.,[]<>
  5. কোনও ইওফ প্রতীক নেই

একটি খুব ভাল পরীক্ষা এখানে পাওয়া যাবে । এটি একটি সংখ্যা পড়ে এবং তারপরে সেই সংখ্যা পর্যন্ত প্রাথমিক সংখ্যা মুদ্রণ করে। লিঙ্ক পচা রোধ করতে এখানে কোডের একটি অনুলিপি দেওয়া হয়েছে:

compute prime numbers
to use type the max number then push Alt 1 0
===================================================================
======================== OUTPUT STRING ============================
===================================================================
>++++++++[<++++++++>-]<++++++++++++++++.[-]
>++++++++++[<++++++++++>-]<++++++++++++++.[-]
>++++++++++[<++++++++++>-]<+++++.[-]
>++++++++++[<++++++++++>-]<+++++++++.[-]
>++++++++++[<++++++++++>-]<+.[-]
>++++++++++[<++++++++++>-]<+++++++++++++++.[-]
>+++++[<+++++>-]<+++++++.[-]
>++++++++++[<++++++++++>-]<+++++++++++++++++.[-]
>++++++++++[<++++++++++>-]<++++++++++++.[-]
>+++++[<+++++>-]<+++++++.[-]
>++++++++++[<++++++++++>-]<++++++++++++++++.[-]
>++++++++++[<++++++++++>-]<+++++++++++.[-]
>+++++++[<+++++++>-]<+++++++++.[-]
>+++++[<+++++>-]<+++++++.[-]

===================================================================
======================== INPUT NUMBER  ============================
===================================================================
+                          cont=1
[
 -                         cont=0
 >,
 ======SUB10======
 ----------

 [                         not 10
  <+>                      cont=1
  =====SUB38======
  ----------
  ----------
  ----------
  --------

  >
  =====MUL10=======
  [>+>+<<-]>>[<<+>>-]<     dup

  >>>+++++++++
  [
   <<<
   [>+>+<<-]>>[<<+>>-]<    dup
   [<<+>>-]
   >>-
  ]
  <<<[-]<
  ======RMOVE1======
  <
  [>+<-]
 ]
 <
]
>>[<<+>>-]<<

===================================================================
======================= PROCESS NUMBER  ===========================
===================================================================

==== ==== ==== ====
numd numu teid teiu
==== ==== ==== ====

>+<-
[
 >+
 ======DUP======
 [>+>+<<-]>>[<<+>>-]<

 >+<--

 >>>>>>>>+<<<<<<<<   isprime=1

 [
  >+

  <-

  =====DUP3=====
  <[>>>+>+<<<<-]>>>>[<<<<+>>>>-]<<<

  =====DUP2=====
  >[>>+>+<<<-]>>>[<<<+>>>-]<<< <


  >>>


  ====DIVIDES=======
  [>+>+<<-]>>[<<+>>-]<   DUP i=div

  <<
  [
    >>>>>+               bool=1
    <<<
    [>+>+<<-]>>[<<+>>-]< DUP
    [>>[-]<<-]           IF i THEN bool=0
    >>
    [                    IF i=0
      <<<<
      [>+>+<<-]>>[<<+>>-]< i=div
      >>>
      -                  bool=0
    ]
    <<<
    -                    DEC i
    <<
    -
  ]

  +>>[<<[-]>>-]<<          
  >[-]<                  CLR div
  =====END DIVIDES====


  [>>>>>>[-]<<<<<<-]     if divides then isprime=0


  <<

  >>[-]>[-]<<<
 ]

 >>>>>>>>
 [
  -
  <<<<<<<[-]<<

  [>>+>+<<<-]>>>[<<<+>>>-]<<<

  >>




  ===================================================================
  ======================== OUTPUT NUMBER  ===========================
  ===================================================================
  [>+<-]>

  [
   ======DUP======
   [>+>+<<-]>>[<<+>>-]<


   ======MOD10====
   >+++++++++<
   [
    >>>+<<              bool= 1
    [>+>[-]<<-]         bool= ten==0
    >[<+>-]             ten = tmp
    >[<<++++++++++>>-]  if ten=0 ten=10
    <<-                 dec ten     
    <-                  dec num
   ]
   +++++++++            num=9
   >[<->-]<             dec num by ten

   =======RROT======
      [>+<-]
   <  [>+<-]
   <  [>+<-]
   >>>[<<<+>>>-]
   <

   =======DIV10========
   >+++++++++<
   [
    >>>+<<                bool= 1
    [>+>[-]<<-]           bool= ten==0
    >[<+>-]               ten = tmp
    >[<<++++++++++>>>+<-] if ten=0 ten=10  inc div
    <<-                   dec ten     
    <-                    dec num
   ]
   >>>>[<<<<+>>>>-]<<<<   copy div to num
   >[-]<                  clear ten

   =======INC1=========
   <+>
  ]

  <
  [
   =======MOVER=========
   [>+<-]

   =======ADD48========
   +++++++[<+++++++>-]<->

   =======PUTC=======
   <.[-]>

   ======MOVEL2========
   >[<<+>>-]<

   <-
  ]

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

  ===================================================================
  =========================== END FOR ===============================
  ===================================================================


  >>>>>>>
 ]
 <<<<<<<<



 >[-]<
  [-]
 <<-
]

======LF========

++++++++++.[-]
@

উদাহরণ রান:

$ python2 bf.py PRIME.BF 
Primes up to: 100
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97
code-golf  interpreter  brainfuck 
— Alexandru
সূত্র
5
আপনার মেমোরির আকার 1) মেমোরি 2 সম্পর্কে স্পষ্ট করা উচিত 4) মেমরিটি চারদিকে প্রদত্ত 4) হতে পারে অন্য কোনও বিবরণ
— নাকিলন
3
আমি দু'টি বিভাগ থাকা উচিত কিনা তা অবাক করে: সেই প্রোগ্রামগুলি যেগুলি eval ব্যবহার করে (বা সংকলনের জন্য শেল আউট) - এবং যেগুলি না।
— এমটিএনভিউমার্ক
34
আমি কাউকে ব্রেইনফাকের মধ্যে এর উত্তর দেখতে দেখতে ভালো লাগবে।
— হানেশ
3
"ইওএফ প্রতীক নেই" এর অর্থ কী? ,EOF এ চেষ্টা করার পরে যে সেল মানটি অপরিবর্তিত রয়েছে ? অথবা ,ইওএফ চেষ্টা করার সময় কোনও মান বাছাই করা আমাদের উপর নির্ভর করে? বা ইওএফ সম্পূর্ণরূপে সংজ্ঞায়িত আচরণ?
— মার্টিন এন্ডার
3
তেমনিভাবে, কেউ যখন 30 কে কোষগুলি অন্যদিকে ছেড়ে যাওয়ার চেষ্টা করে তখন কী হবে? টেপ মাথাটি স্থানে থাকা উচিত নাকি এই অপরিবর্তিত আচরণ?
— মার্টিন এন্ডার

উত্তর:

46

পার্ল, 120 138

%c=qw(> $p++ < $p-- + D++ - D-- [ while(D){ ] } . print+chrD , D=ord(getc));
$/=$,;$_=<>;s/./$c{$&};/g;s[D]'$b[$p]'g;eval

এটি নির্দোষভাবে হ্যালো.বিএফ এবং প্রাইমস.বিএফ চালায়:

$ perl bf.pl hello.bf
Hello World!
$ perl bf.pl prime.bf
Primes up to: 100
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97

প্রারম্ভিককরণ: পার্ক অনুবাদ টেবিলের মধ্যে অপকডটি সঞ্চিত আছে %c। পঠনযোগ্য ফর্মটি দেখতে এমন:

%c=(
  '>' => '$p++',
  '<' => '$p--',
  '+' => '$b[$p]++',
  '-' => '$b[$p]--',
  '[' => 'while($b[$p]){',
  ']' => '}',
  '.' => 'print chr$b[$p]',
  ',' => '$b[$p]=ord(getc)',
);

পদক্ষেপ 1: স্লুর্প প্রোগ্রামের ইনপুটটিতে $_অনুবাদ টেবিলটি ব্যবহার করে পার্ল কোডে রূপান্তর করুন । undefএই পদক্ষেপে মন্তব্যগুলি স্বয়ংক্রিয়ভাবে ছিনিয়ে নেওয়া হয় (এর সাথে প্রতিস্থাপন করা )।

পদক্ষেপ 2: সমস্ত $b[$p]ঘটনা সঙ্কুচিত করুন

পদক্ষেপ 3: ব্যবহার করে প্রোগ্রামটি চালু করুন eval।

— জেবি
সূত্র
শুধু পার্ল এর ব্যবহার qwসিনট্যাক্স সংজ্ঞায়িত করতে %c7 কম অক্ষর জন্য ভাল (আপনি বলার আছে হবে - সরাসরি print+chr$b[$p]এবং ord(getc), যদিও)
— ভিড়
আমি 18 রক্ষা গণনা ... ধন্যবাদ! (এক মিনিটের মধ্যে আপডেট হচ্ছে)
— জেবি
1
@ অলিভকোডার আপনি পৃথিবীতে কি সম্পর্কে কথা বলছেন?
— জেবি
% C সারণিটি প্রথম লাইনে ঘোষিত এবং সংজ্ঞায়িত করা হয়; এর চরিত্রগুলি পুরোপুরি হিসাব করা হয়।
— জেবি
@ জেবি হেই, আমি ভুলক্রমে আপনার উত্তরে ভোটটি চাপলাম এবং এটি লক হয়ে গেছে, আপনি কি এটিকে সম্পাদন করতে পারবেন যাতে আমি ভোটকে উল্টো করে দিতে পারি?
— সাইক্লোহেক্সানল।
67

পাইথন (কোনও ফল নেই), 317 বাইট

from sys import*
def f(u,c,k):
 while(c[1]>=k)*u:
  j,u='[]<>+-,.'.find(u[0]),u[1:];b=(j>=0)*(1-j%2*2);c[1]+=b*(j<2)
  while b*c[c[0]]and j<1:f(u,c,k+1);c[1]+=1
  b*=c[1]==k;c[[0,c[0],2][j/2-1]]+=b
  if(j==6)*b:c[c[0]]=ord(stdin.read(1))
  if(j>6)*b:stdout.write(chr(c[c[0]]))
f(open(argv[1]).read(),[-1]+[0]*30003,0)
— boothby
সূত্র
70
এর জন্য +1f(u,c,k)
— জোয়েল করনেট
9
এটি হ'ল একটি সুন্দর শব্দ, স্যার
— গ্লোবাই
-1 বাইট আপনি যদি প্রতিস্থাপন while b*c[c[0]]and j<1করেনwhile b*c[c[0]]*(j<1)
— ড্যানিল তুতুবালিন
50

16 বিট 8086 মেশিন কোড: 168 বাইট

এখানে বেস 64 এনকোডড সংস্করণ রয়েছে, রূপান্তর করুন এবং 'bf.com' হিসাবে সংরক্ষণ করুন এবং উইন্ডোজ কমান্ড প্রম্পট থেকে চালান: 'বিএফ প্রগমনাম'

gMYQUoDGEFKzgI1XAgIfiEcBtD3NIR8HcmOL2LQ/i88z0s0hcleL2DPA86sz/zP2/sU783NHrL0I
AGgyAU14DTqGmAF194qOoAH/4UfDJv4Fwyb+DcO0AiaKFc0hw7QBzSGqT8MmODV1+jPtO/NzDaw8
W3UBRTxddfJNee/DJjg1dPoz7U509YpE/zxddQFFPFt18U157sM+PCstLixbXUxjTlJWXmV+

সম্পাদনা

এক্সিকিউটেবলটি তৈরি করতে এখানে কিছু এসেম্বলার (এ style86 শৈলী) রয়েছে (মূল উত্সটি ভুল করে রেখেছি বলে আমি এটিকে প্রকৌশলীকে বিপরীত করতে হয়েছিল!)

    add dh,10h                              
    push dx                                 
    add dh,10h                              
    push dx                                 
    mov bl,80h                              
    lea dx,[bx+2]                         
    add bl,[bx]                            
    mov [bx+1],al                         
    mov ah,3dh                              
    int 21h                                 
    pop ds                                 
    pop es                                 
    jb ret                               
    mov bx,ax                              
    mov ah,3fh                              
    mov cx,di                              
    xor dx,dx                              
    int 21h                                 
    jb ret                               
    mov bx,ax                              
    xor ax,ax                              
    repz stosw                                     
    xor di,di                              
    xor si,si                              
    inc ch                                 
program_loop:
    cmp si,bx                              
    jnb ret                               
    lodsb                                    
    mov bp,8                            
    push program_loop
symbol_search:                       
    dec bp                                 
    js ret
    cmp al,[bp+symbols]
    jnz symbol_search
    mov cl,[bp+instructions]
    jmp cx                                 
forward:
    inc di                                 
    ret                                    
increment:
    inc b es:[di]                      
    ret                                    
decrement:
    dec b es:[di]                      
    ret                                    
output:
    mov ah,2                              
    mov dl,es:[di]                            
    int 21h                                 
    ret                                    
input:
    mov ah,1                              
    int 21h                                 
    stosb                                    
backward:
    dec di                                 
    ret                                    
jumpforwardifzero:
    cmp es:[di],dh                            
    jnz ret                               
    xor bp,bp
l1: cmp si,bx                              
    jnb ret
    lodsb                                    
    cmp al,'['                              
    jnz l2
    inc bp
l2: cmp al,']'                              
    jnz l1
    dec bp                                 
    jns l1
    ret                                    
jumpbackwardifnotzero:
    cmp es:[di],dh                            
    jz  ret
    xor bp,bp
l3: dec si                                 
    jz  ret
    mov al,[si-1]                         
    cmp al,']'
    jnz l4
    inc bp  
l4: cmp al,'['                              
    jnz l3
    dec bp                                 
    jns l3
    ret                                    
symbols:
    db '><+-.,[]'
instructions:
    db forward and 255
    db backward and 255
    db increment and 255
    db decrement and 255
    db output and 255
    db input and 255
    db jumpforwardifzero and 255
    db jumpbackwardifnotzero and 255
— Skizz
সূত্র
আমি প্রোগ্রামটির একটি উত্স কোড সংস্করণ যুক্ত করেছি। আমি কেবল লক্ষ্য করেছি যে নন-বিএফ চরিত্রগুলি প্রোগ্রামটিকে উপেক্ষা করার পরিবর্তে প্রস্থান করতে পারে cause এটি ঠিক করা সহজ এবং আমি এটি লোকেরা নিজেরাই এটি করার অনুশীলন হিসাবে ছেড়ে দেব।
— স্কিজেড
আমার মনে আছে আমি 10 বছর আগে লিনাক্স ইএলএফ সংস্করণটি 166 বাইট পেয়েছিলাম, এখানে Muppetlabs.com/~breadbox/software/tiny
— এমমানুয়েল
39

ব্রেনফাক , 843 691 বাইট

সম্পাদনা: এটি পুনরায় দেখার সিদ্ধান্ত নিয়েছে এবং বাইটগুলি বন্ধ করে দেওয়ার জন্য একটি বিস্ময়কর উপায় খুঁজে পেয়েছে

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

এটি theচ্ছিক code!inputযেখানে ফর্ম ইনপুট লাগে !input। এটি নিজে নেতিবাচক কোষ ব্যবহার না করে নেতিবাচক কোষগুলিকে সিমুলেট করে এবং (30000-(length of code+6))/2কোষ পর্যন্ত সঞ্চয় করতে পারে ।

এটি অনলাইন চেষ্টা করুন!

— জো কিং
সূত্র
শুধু নিশ্চিত আমি এই অধিকার পেয়েছেন, আমি যদি এই প্রোগ্রামের সাথে এই প্রোগ্রাম দৌড়ে করতে পারতাম নীড় এটি 5 মাত্রা গভীর এবং এখনও দৈর্ঘ্য 262. কোড-ইনপুট হ্যান্ডলিং
— Draco18s
@ ড্রাকো 18 আমার সন্দেহ হয় যে এর আগে আপনি 30000 কোষগুলি সরিয়ে ফেলবেন, যেহেতু প্রতিটি নেস্টেড ইন্টারপ্রেটারের আকার তাত্পর্যপূর্ণভাবে বৃদ্ধি পায়। আমি মনে করি আপনি 2 পেয়ে যাবেন, সম্ভবত 3 স্তর গভীর
— জো কিং
এমনকি 3 গভীর হাস্যকর মূর্খ হবে।
— Draco18s
27

রুবি 1.8.7, 188 185 149 147 টি অক্ষর

eval"a=[i=0]*3e4;"+$<.bytes.map{|b|{?.,"putc a[i]",?,,"a[i]=getc",?[,"while a[i]>0",?],"end",?<,"i-=1",?>,"i+=1",?+,"a[i]+=1",?-,"a[i]-=1"}[b]}*";"

কিছুটা পঠনযোগ্য সংস্করণ:

code = "a = [0] * 3e4; i = 0;"
more_code ARGF.bytes.map {|b|
  replacements = {
    ?. => "putc a[i]",
    ?, => "a[i] = getc",
    ?[ => "while a[i] > 0 do",
    ?] => "end",
    ?< => "i -= 1",
    ?> => "i += 1",
    ?+ =>"a[i]+=1",
    ?- =>"a[i]-=1"
  }
  replacements[b]
}.join(";")
eval code+more_code

আপনি দেখতে পান যে আমি নির্লজ্জভাবে হোস্ট ভাষায় অনুবাদ করার এবং তারপরে এটি চালানোর জন্য ইওল ব্যবহার করার ধারণাটি চুরি করেছি।

— sepp2k
সূত্র
আপনি একটি বাইট বাইট শূন্য তুলনায় বন্ধ শেভ করতে >0বরং সমতা পরীক্ষা চেয়ে: !=0। চশমাটি স্বাক্ষরবিহীন বলে এবং ওভারফ্লো অপরিজ্ঞাত।
— বেনামে কাপুরুষ
3e4এর 30000
— বিপরীতেও
@ চার্লি: ধন্যবাদ যদিও তা যথাযথ হলেও আমি কোডটি লিখতে গিয়ে "স্বাক্ষরবিহীন" বলিনি। আমি সত্যই জানতাম না যে আপনি 3e4 লিখতে পারেন যদিও। এটি একটি খুব ভাল পয়েন্ট এবং জানতে ভাল।
— sepp2k
File.read($*.pop).bytes-> $<.bytesখুব কাজ করা উচিত
— আরনাউড লে ব্ল্যাঙ্ক
1
আক্ষরিক হ্যাশ তৈরির জন্য রুবি 1.8.7 এর একটি আরও ছোট সিনট্যাক্স রয়েছে: {?a,"foo"}যা এর সমতুল্য {?a=>"foo"}। এবং এখানে পরীক্ষা দেখায় যে আপনি আসলে প্রতিস্থাপন করতে পারেন File.read($*.pop).bytesসঙ্গে $<কোন সমস্যা ছাড়াই। এছাড়াও সবকিছুকে কিছুটা অন্তর্ভুক্ত করা যেমন eval"a[0]..."+$<.bytes.map{?.,"putc a[i]",...}*";"সমাধানটিকে আরও কয়েকটি অক্ষর দ্বারা সংক্ষিপ্ত করে তোলে।
— ভেন্টোরো
26

বাইনারি লাম্বদা ক্যালকুলাস 112

প্রোগ্রামটি নীচে হেক্স ডাম্পে দেখানো হয়েছে

00000000  44 51 a1 01 84 55 d5 02  b7 70 30 22 ff 32 f0 00  |DQ...U...p0".2..|
00000010  bf f9 85 7f 5e e1 6f 95  7f 7d ee c0 e5 54 68 00  |....^.o..}...Th.|
00000020  58 55 fd fb e0 45 57 fd  eb fb f0 b6 f0 2f d6 07  |XU...EW....../..|
00000030  e1 6f 73 d7 f1 14 bc c0  0b ff 2e 1f a1 6f 66 17  |.os..........of.|
00000040  e8 5b ef 2f cf ff 13 ff  e1 ca 34 20 0a c8 d0 0b  |.[./......4 ....|
00000050  99 ee 1f e5 ff 7f 5a 6a  1f ff 0f ff 87 9d 04 d0  |......Zj........|
00000060  ab 00 05 db 23 40 b7 3b  28 cc c0 b0 6c 0e 74 10  |....#@.;(...l.t.|
00000070

এর ইনপুটটি ব্রেনফাক প্রোগ্রামের সমন্বয়ে প্রত্যাশা করে (কেবল বিটগুলিতে 0,1,4 দেখতে পারার মধ্যে পার্থক্য রয়েছে, - + <>] [) এর পরে একটি], ব্রেইনফাক প্রোগ্রামটির জন্য ইনপুট রয়েছে।

Xxd -r> bf.Blc দিয়ে উপরের হেক্স ডাম্পটি সংরক্ষণ করুন

Https://tromp.github.io/cl/cl.html থেকে একটি ব্লক দোভাষী নিন

cc -O2 -DM=0x100000 -m32 -std=c99 uni.c -o uni
echo -n "++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.]" > hw.bf
cat bf.Blc hw.bf | ./uni

ওহে বিশ্ব!

— জন ট্রম্প
সূত্র
1
এটি এমনকি কেন বিদ্যমান? স্পষ্টতই, এটি গবেষণার ক্ষেত্রেও রয়েছে । ওও
— ইসিয়া মিডোস
সুতরাং এটি মন্তব্য করা ব্রেনফাক প্রোগ্রামগুলির সাথে কাজ করবে না?
— kamoroso94
না, প্রথমে মন্তব্যগুলি সরিয়ে ছাড়াই নয়।
— জন ট্রম্প
18

রেটিনা 0.8.2 , 386 391 386 বাইট

কোডে অপ্রিন্টযোগ্য NUL ( 0x00) অক্ষর রয়েছে। এটি এখনও সুপার গল্ফ হয়নি, কারণ এটি ইতিমধ্যে সত্যই ধীর এবং যদি আমি এটি আরও গল্ফ করি তবে জানি না যে এটি শেষ হতে কত সময় লাগবে। প্রাইম-সন্ধানের নমুনায় সময় শেষ হয়ে যায়।

অনলাইন ইন্টারপ্রেটারে বা আমার প্রোগ্রামে বাগ থাকতে পারে (শীর্ষস্থানীয় নতুন লাইনগুলি আউটপুটটিতে দেখায় না?)

ইনপুট লাগে <code>│<input>। না, এটি পাইপ নয় ( |)। এটি ইউনিকোড চরিত্র U+2502। কোডটি ইউনিকোড অক্ষরও ব্যবহার করে ÿ▶◀├║। ইউনিকোড অক্ষরগুলি সমস্ত ASCII অক্ষরের ইনপুট সমর্থন করার জন্য ব্যবহৃত হয়। অতএব, এই অক্ষরগুলি একটি নন-এএসসিআইআই অক্ষর দ্বারা কোড থেকে পৃথক করা দরকার।

এটি অনলাইনে চেষ্টা করুন

s`^.*
▶$0├║▶
s{`(▶>.*║.*)▶(.)(.?)
$1$2▶$3
▶$
▶
║▶
║▶
(▶<.*║.*)(.)▶
$1▶$2
T`ÿ-`o`(?<=▶\+.*║.*▶).
^\+

T`-ÿ`ÿo`(?<=▶-.*║.*▶).
^-

(▶\..*├.*)(║.*▶)(.)
$1$3$2$3
(▶,.*│)(.?)(.*├.*▶).
$1$3$2
▶\[(.*║.*▶)
[▶▶${1}
{`(▶▶+)([^[\]]*)\[
$2[$1▶
}`▶(▶+)([^[\]]*)\]
$2]$1
r`([[\]]*)▶\](.*║.*▶[^])
$1◀◀]$2
r{`\[([^[\]]*)(◀+)◀
$2[$1
}`\]([^[\]]*)(◀◀+)
$2◀]$1
◀
▶
}`▶([^│])(.*║)
$1▶$2
s\`.*├|║.*

নোট করুন সেখানে একটি ট্রেলিং নিউলাইন রয়েছে।

সংক্ষিপ্ত বর্ণনা:

জিরোগুলি 0x00টেপের জন্য ব্যবহৃত হয়, যা অসীম। প্রথম প্রতিস্থাপনটি ফর্মটিতে দোভাষী স্থাপন করে ▶<code>│<input>├<output>║▶<tape>, যেখানে প্রথমটি ▶কোডের জন্য পয়েন্টার এবং দ্বিতীয়টি টেপের জন্য পয়েন্টার।

ÿহ'ল 0xFF(255), যা শূন্যের কাছাকাছি কোষগুলি গুটিয়ে রাখতে ট্রান্সলিটেশন (প্রয়োগের জন্য ব্যবহৃত হয় ) +এবং ব্যবহৃত হয় -।

◀কেবল পঠনযোগ্যতার জন্য ব্যবহৃত হয় (যদি প্রোগ্রামটি মাঝখানে বন্ধ হয়ে যায় বা আপনি প্রোগ্রামটি মধ্য-সম্পাদন দেখতে চান)। অন্যথায়, আপনি কীভাবে পয়েন্টারটি চলছিল তা বলতে পারেন না।

মন্তব্য কোড:

s`^.*                       # Initialize
▶$0├║▶
s{`(▶>.*║.*)▶(.)(.?)        # >
$1$2▶$3
▶$
▶
║▶                          # <
║▶
(▶<.*║.*)(.)▶
$1▶$2
T`ÿ-`o`(?<=▶\+.*║.*▶).      # +
^\+

T`-ÿ`ÿo`(?<=▶-.*║.*▶).      # -
^-

(▶\..*├.*)(║.*▶)(.)         # .
$1$3$2$3
(▶,.*│)(.?)(.*├.*▶).        # ,
$1$3$2
▶\[(.*║.*▶)                 # [
[▶▶${1}
{`(▶▶+)([^[\]]*)\[
$2[$1▶
}`▶(▶+)([^[\]]*)\]
$2]$1
r`([[\]]*)▶\](.*║.*▶[^])    # ]
$1◀◀]$2
r{`\[([^[\]]*)(◀+)◀
$2[$1
}`\]([^[\]]*)(◀◀+)
$2◀]$1
◀
▶
}`▶([^│])(.*║)              # next instruction
$1▶$2
s\`.*├|║.*                  # print output

নাল বাইটের জায়গায় শূন্য সহ কোডের জন্য এখানে ক্লিক করুন । যে কোনও ঘটনাকে $0নাল দিয়ে প্রতিস্থাপন করা উচিত নয়।

সম্পাদনা : এখন খালি ইনপুট সমর্থন করে এবং নতুন লাইনের পিছনে চাপ দেয়।

অসীম আউটপুট এখন সমর্থিত। (৪০৩ বাইট)

— mbomb007
সূত্র
আমি এক ধরনের ইচ্ছা করি যে আমি <code>এবং <tape>একে অপরের পাশে রেখেছি (যদিও এটি আরও বেশি চরিত্র হতে চাই) যাতে এসএমবিএফ অনুবাদকের কাছে স্থানান্তর করা আরও সহজ হয়ে যায়, যদি আমি কখনও এটি করার সিদ্ধান্ত নিই।
— mbomb007
14

টিআই-বেসিক, 264 বাইট

টিআই-বেসিকের সীমাবদ্ধতার কারণে, এটি আসলে এই চ্যালেঞ্জের জন্য যোগ্যতা অর্জন করে না কারণ এটি নিয়ম 2 ভঙ্গ করে; ক্যালকুলেটরগুলির র‌্যাম অত্যন্ত সীমাবদ্ধ এবং এর মতো কিছু করা 30000->dim(L1(আমি স্ট্যাক / অ্যারের জন্য L1 ব্যবহার করি) এটি নিক্ষেপ করতে বাধ্য করবে ERR:MEMORY। যেমন, স্ট্যাক / অ্যারেটি 1 আকারে শুরু হয় এবং পয়েন্টারটি এর শেষের আগে কোনও উপাদানটির দিকে ইশারা দিলে বৃদ্ধি পায়। এটি নিয়ম 3 কেও ভেঙে দেয় কারণ এটি ইতিমধ্যে নিয়ম 2 ভঙ্গ করে তাই আমিও কোনও সেল-আকারের সীমাটি নিয়ে বিরক্ত করতে পারি না।

সম্ভবত এখনও গল্ফ করা যেতে পারে ... প্রথম জমা দেওয়ার পরে আমি এক বা দুটি সম্পাদনা করেছি, তবে নীচের সংস্করণটি যদি কাজ না করে তবে May মে '15 এর সম্পাদনায় ফিরে যান এবং এটি ব্যবহার করুন পরিবর্তে কোড এছাড়াও, টিআই-বেসিকের প্রকৃতপক্ষে কোনও এসসিআইআই নেই বলে এটি কোনও আকারের (এবং কোনও সংখ্যা যে কোনও পরিবর্তনশীল বা অভিব্যক্তির মতো ফিরিয়ে দেয়) ইনপুট হিসাবে গ্রহণ করে এবং সংখ্যায় আউটপুট দেয়।

এটিকে একটি .8 এক্সপ্রেসে তৈরি করতে সোর্সকোডারটি ব্যবহার করুন তারপরে এটি টিআই-কানেক্ট বা টিআইএলপি বা কোনও কিছুর সাহায্যে আপনার ক্যালকুলেটরে প্রেরণ করুন এবং আপনার ব্রেইনফাক প্রোগ্রামটি ডাবল কোটে অন্তর্ভুক্ত করুন এবং তারপরে আপনি টিআই-বেসিক প্রোগ্রামটির নাম দিয়েছেন। উদাহরণস্বরূপ, যদি আপনি এটি BRAINF নামে, আপনি এই মত একটি প্রোগ্রাম চালানো চাই: "brainfuck goes here":prgmBRAINF। আপনি যে অন্যান্য কমান্ডের বিছিন্ন করে যখন এটি সনাক্ত আপনার Calc একটি শেল থাকে prgm, টোকেন যদিও, এই কাজ: "brainfuck goes here" -> press ENTER -> prgmBRAINF।

seq(inString("<>-+.,[]",sub(Ans,S,1)),S,1,length(Ans->L2
cumSum((Ans=7)-(Ans=8->L3
seq(Ans(X),X,dim(Ans),1,~1->L4
1->P:DelVar L11->dim(L1 //this is the same as DelVar L1:1->dim(L1 as DelVar does not require a colon or newline after its argument
For(S,1,dim(L2
L2(S->T
P-(T=1)+(T=2->P
dim(L1
Ans+(P-Ans)(P>Ans->dim(L1
L1(P)-(T=3)+(T=4->L1(P
If T=5
Disp Ans
If T=6:Then
Input V
V->L1(P
End
If T=7 and not(L1(P
S+2+sum(not(cumSum(L3(S)-1=seq(L3(X),X,S+1,dim(L3->S
1-S+dim(L3
If T=8 and L1(P
S-sum(not(cumSum(L4(Ans)=seq(L4(X),X,Ans+1,dim(L4->S
End

আপনি আপনার কম্পিউটার থেকে আপনার ক্যালকুলেটর সংযোগ করার একটি উপায় না থাকে তাহলে করতে এবং এই পরিবর্তে অন Calc আউট টাইপ করতে চান (আমি কল্পনা করতে পারি না কেন আপনি চান অনুভব করি, কিন্তু আমি একমত নই) লক্ষ করুন যে ->হয় STO>উপরের বোতাম কী, ~ENTER এর পরের নেতিবাচক প্রতীক, এবং L<number>পাওয়া তালিকার টোকেনের সাথে পাওয়া সমস্ত দৃষ্টান্ত প্রতিস্থাপন করতে2ND -> <number on keypad>

ধন্যবাদ Thomas-Kwa (অন্তত, আমি মনে করি যে, তার স্ট্যাক USERNAME- এর) আমাকে এই নিখুত সাহায্য করার জন্য, বিশেষ করে সঙ্গে [এবং ]নির্দেশাবলী।

— এমআই রাইট
সূত্র
1
আপনার চারপাশে পেরেনস দরকার Ans+S?
— জাকারিয়া
@ জ্যাচারý ভাল ক্যাচ, না। আমি অবশ্যই পেমডাস কীভাবে কাজ করি বা অন্য কিছু সম্পর্কে অবশ্যই নিশ্চিত ছিলাম না ... আমি সম্পাদনা করা থেকে বিরত থাকব, তবে এত দিন হয়ে গেছে যে অবশ্যই এই পোস্টটি সামনের দিকে ধাক্কা দেওয়া উপযুক্ত নয় এবং কারণ দ্বি-বাইট হ্রাস উত্তর লোকেদের উপর কোনও ধরণের সুবিধা দিতে যাচ্ছে না।
— এমআই রাইট
1
আমার মনে আছে 2-3 বছর আগে যখন আমি এই প্রোগ্রামটি আমার ক্যালকুলেটরে ব্রেইনফ *** ব্যাখ্যা করতে ব্যবহার করি। এবং, এটি একটি বুদ্ধিমান মস্তিষ্কের *** প্রশ্ন, আমি মনে করি এটি সৎ হওয়ার পক্ষে শীর্ষে থাকা উচিত।
— জাকারি
1
আসলে, আমি মনে করি যে পুরো লাইনটি হতে পারে S-sum(not(cumSum(L4(Ans)=seq(L4(X),X,Ans+1,dim(L4->S। ( a-a=0)। এবং ওহে, এখানে অপারেশন জিনিসটির এক আদেশ ভুলে যাওয়ার বিষয়ে চিন্তা করবেন না, আমি দেখেছি পুরো একটি হোস্ট %একটি চ্যালেঞ্জের (মোড) এর জন্য অপারেশন ক্রম ভুলে গেছে ।
— জাকারি
1
ওহ ডাং, হ্যাঁ ঠিক আছে, এটি কমপক্ষে 10 বাইট বন্ধ দেয় যেহেতু যদি ওয়ান-লাইনার পাশাপাশি করা যায় তবে আরও কিছু জিনিস ... পাশাপাশি সম্পাদনা করতে পারে। এই জিনিসগুলি পরীক্ষা করতে আপনি বছরের মতো প্রথম বার আমার ক্যালকুলেটরকে বেত্রাঘাত করতে পেরেছেন, হাহা
— এমআই রাইট
13

পাইথন 275 248 255

আমি চেষ্টা করে দেখার চেষ্টা করেছি।

import sys
i=0
b=[0]*30000
t=''
for e in open(sys.argv[1]).read():
 t+=' '*i+['i+=1','i-=1','b[i]+=1','b[i]-=1','sys.stdout.write(chr(b[i]))','b[i]=ord(sys.stdin.read(1))','while b[i]:','pass','']['><+-.,['.find(e)]+'\n'
 i+=(92-ord(e))*(e in'][')
exec t
— Alexandru
সূত্র
12
ঝরঝরে, আপনি ব্রেনফাক ব্যবহার করে অজগর উত্স কোড তৈরি করছেন।
1
আপনি ১ টি চরটি ছিনিয়ে নিতে পারেন, "sys হিসাবে s হিসাবে আমদানি করুন" এবং "sys" কে "s" এর জায়গায় রেখে দিতে পারেন
— আপনি
মনে রাখবেন এটি আসলে 247 টি অক্ষর। (কদর্য স্থান পরে দেখুন exec t?)। যদি আপনি এস.মার্কের টিপ ব্যবহার করেন এবং পুরো forচক্রটিকে এক লাইনে পরিণত করেন তবে আপনি এটি 243 অক্ষরে সঙ্কুচিত করতে পারেন।
— ওলেহ প্রিপিন
এটি যে কোনও ইনপুট যুক্ত করতে ব্যর্থ হয় [], একটি বৈধ যদিও তুচ্ছ বিএফ প্রোগ্রাম। আমি এমন একটি সম্পাদনার পরামর্শ দিয়েছি যা এটি ঠিক করে, তবে চরিত্রের সংখ্যা বাড়িয়ে তোলে। চরিত্রের গণনা আরও কমাতে, আপনি এর পরিবর্তে from sys import *এবং ব্যবহার করতে পারেন । 'i+=1,...'.split(',')['i+=1',...]
— বুথবি
7
আমি +1, কিন্তু অনেক উন্নতি প্রস্তাবিত হয়েছে এবং প্রয়োগ করা হয়নি।
— mbomb007
12

হাস্কেল, 457 413 টি অক্ষর

import IO
import System
z=return
'>'#(c,(l,d:r))=z(d,(c:l,r))
'<'#(d,(c:l,r))=z(c,(l,d:r))
'+'#(c,m)=z(succ c,m)
'-'#(c,m)=z(pred c,m)
'.'#t@(c,_)=putChar c>>hFlush stdout>>z t
','#(_,m)=getChar>>=(\c->z(c,m))
_#t=z t
_%t@('\0',_)=z t
i%t=i t>>=(i%)
b('[':r)=k$b r
b(']':r)=(z,r)
b(c:r)=f(c#)$b r
b[]=(z,[])
f j(i,r)=(\t->j t>>=i,r)
k(i,r)=f(i%)$b r
main=getArgs>>=readFile.head>>=($('\0',("",repeat '\0'))).fst.b

এই কোডটি বিএফ প্রোগ্রামটিকে "সংকলন" করে IOফর্মের ক্রিয়ায় State -> IO Stateএকটি অনন্ত স্ট্রিংয়ের জিপার।

দুঃখের বিষয় যে আমাকে বাফারিং বন্ধ করতে 29 টি অক্ষর ব্যয় করতে হয়েছিল। এগুলি ছাড়া এটি কাজ করে তবে আপনাকে ইনপুট টাইপ করার আগে প্রম্পটগুলি দেখতে পাবেন না। সংকলক নিজেই ( b, fএবং k) কেবলমাত্র 99 টি অক্ষর, রানটাইম ( #এবং %) 216 The

>ghc -O3 --make BF.hs 
[1 of 1] Compiling Main             ( BF.hs, BF.o )
Linking BF ...

>./BF HELLO.BF 
Hello World!

>./BF PRIME.BF 
Primes up to: 100
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97

আপডেট ২০১০-০১-১৫: জেবির পরামর্শগুলি অন্তর্ভুক্ত করে, কিছুটা নতুন নামকরণ করেছিলেন, এবং আরও শক্ত করে তোলেনmain

— MtnViewMark
সূত্র
1
আপনার পক্ষে বাফারিংটি কেবলমাত্র থেকে IOএবং আর্গুমেন্ট Systemজাস্ট (-19) থেকে পেতে সক্ষম হওয়া উচিত । বাফারিং ইস্যুটি আমাকেও বিরক্ত করে, কারণ অনুমানটি সত্যই এর উল্লেখ করে না এবং শীর্ষ-ভোট প্রাপ্ত উত্তর এমনকি আমি / ও করি না। আপনার যদি এটি অবশ্যই রাখতে হয় hFlushতবে গ্লোবাল বাফারিং মোড পরিবর্তনের চেয়ে প্রতিটি লেখার পরে এটি সংক্ষিপ্ততর হবে (-34 + 15)।
— জেবি
11

কনভেয়র, 953

এটি সম্ভবত আপনি দেখতে পাবেন সবচেয়ে সুন্দর কোড হতে পারে:

0

:I\1\@p
>#====)
^#====<
PP0
P<=======================<
00t:)01t1  a:P:P:P:P:P:P:^
>===========">">2>">2>">"^
^           +^-^5^ ^5^]^.^
^           "^"^*^"^*^"^"^
^           -^-^6^-^6^-^-^
^           #^#^*^#^*^#^#^
^           P P -^P )^P P
^           P P #^P )^P P
^t1\)t0:))t01   P   -^  1
^===========<   P   #^  0
^  t1\(t0:))t01     P   t
^=============<     P   )
^         t11(t01   0 0 )
^===============<. t P 10
^                 FT#T#=<
^=================< P 
^             t11)t01 
^===================< 10t))0tP00t:(01t(1a:P:
^                     >=====#=>==========">"
^                             ^          ]^[
^                           P ^          "^"
^===========================<=^#=====<   -^-
                            ^==<     ^ PP#^#=
                                     ^===PTPT<
                                     ^  )P P
                                     ^=<=< (
                                       ^===<
— Loovjo
সূত্র
8
আপনি একটি ব্যাখ্যা এবং একটি বাস্তবায়ন একটি লিঙ্ক যোগ করতে পারেন? আমি সৌন্দর্য বুঝতে চাই। ;)
— ডিএলকস
1
ভাল, আমি বর্তমানে এটি বিকাশ করছি, github.com/loovjo/Conveyor এ একটি সংকলক এবং খুব খারাপ ব্যাখ্যা রয়েছে । আপনি যদি এটি বুঝতে চান তবে উত্সটি বেশ পঠনযোগ্য।
— লুভজো
9

সি 284 362 (একটি ফাইল থেকে)

#include <stdio.h>
char b[30000],z[9999],*p=b,c,*a,i;f(char*r,int s){while(c=*a++){if(!s){(c-62)?(c-60)?(c-43)?(c-45)?(c-46)?(c-44)?0:(*p=getchar()):putchar(*p):--*p:++*p:--p:++p;if(c==91)f(a,!*p);else if(c==93){if(!*p)return;else a=r;}}else{if(c==93){--s;if(!*p&&!s)return;}else if(c==91){s++;}}}}main(int c,char**v){fread(z,1,9999,fopen(*++v,"r"));a=z;f(0,0);}

primes:

পুরষ্কার: 100
2 3 5 7 11 13 17 19 19 29 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97
চালু রাখবার জন্য যেকোনো বোতাম চাপুন . । ।

সংকলিত এবং সফলভাবে VS2008 চলমান

মূল সমাধানটি শূন্যে সেট করা লুপগুলি সনাক্ত করতে ব্যর্থ হয়েছিল। গল্ফ এখনও কিছু ঘর। তবে শেষ পর্যন্ত প্রাইম নাম্বার প্রোগ্রামটি সমাধান করে।

Ungolfed:

#include <stdio.h>
char b[30000],z[9999],*p=b,c,*a,i;
f(char*r,int s)
{
    while(c=*a++)
    {   
        if(!s)
        {
            (c-62)?(c-60)?(c-43)?(c-45)?(c-46)?(c-44)?0:(*p=getchar()):putchar(*p):--*p:++*p:--p:++p;
            if(c==91)f(a,!*p);
            else if(c==93){if(!*p)return;else a=r;}
        }
        else
        {
            if(c==93)
            {
                --s;
                if(!*p&&!s)return;
            }
            else if(c==91)
            {
                s++;
            }
        }
    }
}

main(int c,char**v){
    fread(z,1,9999,fopen(*++v,"r"));
    a=z;
    f(0,0);
}

পরীক্ষা:

ওহে বিশ্ব

ROT13

— রেভস , 2 ব্যবহারকারী 92% স্নকমডোনাল্ড
সূত্র
আপনি যখন lলুপ করবেন তখন কি একই পয়েন্টারটি ( ) পরীক্ষা করছেন ? আমার মনে হয় আপনার মাথাটির বর্তমান অবস্থানটি পরীক্ষা করা উচিত ( p)।
— আলেকজান্দ্রু
আমি পয়েন্টারটি বাফারে এবং পয়েন্টারটি প্রবাহে প্রেরণ করি। এটি লুপের শেষে পরীক্ষা করে দেখুন lবাফারের পয়েন্টারটি শূন্যে পৌঁছেছে এবং অন্যথায় এটি লুপটিকে মূল লুপে পুনরায় সেট করে [। নেস্টেড [লুপগুলির জন্য এটি প্রয়োজনীয় ।
— স্নকমডোনাল্ড
1
হ্যাঁ। আমিও তাই ভাবছিলাম. লুপে প্রথমে প্রবেশের সময় আপনাকে পয়েন্টারে মানটি পরীক্ষা করা উচিত নয়, তবে বর্তমান পয়েন্টারের মানটি পরীক্ষা করা উচিত। প্রশ্নে পরীক্ষা পরীক্ষা করুন। আপনার প্রোগ্রামটি স্থগিত।
— আলেকজান্দ্রু
1
আপনি break;elseদ্বারা প্রতিস্থাপন করতে পারেন return;।
— আলেকজান্দ্রু
3
আমার মনে হয় আপনি প্রতিস্থাপন করতে পারেন (c==62)?a:bসঙ্গে (c-62)?b:a।
— আলেকজান্দ্রু
9

পিএইচপি 5.4, 296 294 273 263 261 209 191 183 178 166 টি অক্ষর:

আমি এভাল ব্যবহার না করে এটিকে একটি শট দিয়েছি তবে শেষ পর্যন্ত আমাকে এটি ব্যবহার করতে হয়েছিল

<?$b=0;eval(strtr(`cat $argv[1]`,["]"=>'}',"["=>'while($$b){',"."=>'echo chr($$b);',","=>'$$b=fgetc(STDIN);',"+"=>'$$b++;',"-"=>'$$b--;',">"=>'$b++;',"<"=>'$b--;']));

সমস্ত কমান্ড কাজ করছে। এটি ভেরিয়েবল ভেরিয়েবলকে গুরুতরভাবে অপব্যবহার করে এবং সতর্কবার্তা দেয় ws তবে, যদি কেউ তাদের php.ini কে স্কোলেচ সতর্কতাগুলিতে পরিবর্তন করে (বা পাইপ stderr কে / dev / নাল করে), এটি দুর্দান্ত কাজ করে।

যাচাইকরণ (এটি উইকিপিডিয়া থেকে "হ্যালো ওয়ার্ল্ড!" উদাহরণ ): http://codepad.viper-7.com/O9lYjl

অবহেলিত, 367 365 335 296 267 টি অক্ষর:

<?php
$a[] = $b = 0;
$p = implode("",file($argv[1])); // Shorter than file_get_contents by one char
$m = array("]" => '}', "[" => 'while($a[$b]){',"." => 'echo chr($a[$b]);', "," => '$a[$b]=fgetc(STDIN);', "+" => '$a[$b]++;', "-" => '$a[$b]--;', ">" => '$b++;', "<" => '$b--;');
$p = strtr($p,$m);
@eval($p);

এটি কমান্ড লাইনের মাধ্যমে চালানো উচিত: php bf.php hello.bf

— রেভস , 3 জন 82% Bass5098
সূত্র
8

উইন্ডোজ পাওয়ারশেল, 204

'$c=,0*3e4;'+@{62='$i++
';60='$i--
';43='$c[$i]++
';45='$c[$i]--
';44='$c[$i]=+[console]::ReadKey().keychar
';46='write-host -n([char]$c[$i])
';91='for(;$c[$i]){';93='}'}[[int[]][char[]]"$(gc $args)"]|iex

নির্দেশাবলী এবং তারপর সরাসরি মোটামুটি রূপান্তর Invoke-Expression।

ইতিহাস:

  • 2011-02-13 22:24 (220) প্রথম প্রচেষ্টা।
  • 2011-02-13 22:25 (218) এর 3e4চেয়ে ছোট 30000।
  • 2011-02-13 22:28 (216) অপ্রয়োজনীয় লাইন বিরতি। অক্ষরের পরিবর্তে পূর্ণসংখ্যার সাথে মিল খাটো করা।
  • 2011-02-13 22:34 (207) এর পরিবর্তে হ্যাশ টেবিলের ইনডেক্স ব্যবহার করা হয়েছে switch।
  • 2011-02-13 22:40 (205) আরও ভাল কাস্টিং স্ট্রিংয়ে দুটি বন্ধনী সরিয়ে দেয়।
  • 2011-02-13 22:42 (204) যুক্তির পরে কোনও জায়গার দরকার নেই Write-Host।
— জোয়ি
সূত্র
8

সি, 333 টি অক্ষর

এটি আমার প্রথম বিএফ ইন্টারপ্রেটার এবং প্রথম গল্ফ আমাকে আসলে ডিবাগ করতে হয়েছিল।

এটি ম্যাক ওএস এক্স / জিসিসিতে প্রাইম নম্বর জেনারেটরটি চালায়, তবে #include<string.h>আরও 19 টি অক্ষর ব্যয় করে একটি অতিরিক্ত প্রয়োজন হতে পারে যদি strchrঅন্য প্ল্যাটফর্মের সাথে কাজ করার সংজ্ঞা সংজ্ঞাটি না ঘটে। এছাড়াও, ধরে নেওয়া হয় O_RDONLY == 0। এর intবাইরেও, ঘোষণার বাইরে রেখেM 3 টি অক্ষর সংরক্ষণের তবে এটি C99 অনুগত বলে মনে হয় না। তৃতীয় সঙ্গে একই* মধ্যে b()।

এটি ASCII এনকোডিংয়ের বিশদগুলির উপর নির্ভর করে। ব্রেইনফাক অপারেটরগুলি সমস্ত পরিপূরক জুটি ASCII কোড স্পেসে 2 এর দূরত্ব দ্বারা পৃথক করা হয়। এই প্রোগ্রামে প্রতিটি ফাংশন অপারেটরদের একজোড়া প্রয়োগ করে।

#include<unistd.h>
char C[30000],*c=C,o,P[9000],*p=P,*S[9999],**s=S,*O="=,-\\",*t;
m(){c+=o;}
i(){*c-=o;}
w(){o<0?*c=getchar():putchar(*c);}
b(){if(o>0)*c?p=*s:*--s;else if(*c)*++s=p;else while(*p++!=93)*p==91&&b();}
int(*M[])()={m,i,w,b};
main(int N,char**V){
read(open(V[1],0),P,9e3);
while(o=*p++)
if(t=strchr(O,++o&~2))
o-=*t+1,
M[t-O]();
}
— Potatoswatter
সূত্র
আমি মনে করি আপনি সমস্ত বড় সংখ্যার জন্য 'ই' চিহ্ন ব্যবহার করে এটি আরও সঙ্কুচিত করতে পারেন।
— লুসার ড্রোগ
@ লুজার: আমি প্রথমদিকেও অবাক হয়েছিলাম, তবে ভাষা এবং সংকলক এটির অনুমতি দেয় না। আমি টুইটগুলি সহ আরও 4 টি অক্ষর সঙ্কুচিত করেছিলাম এবং #defineফাংশন টেবিলের পরিবর্তে সম্ভবত টার্সার ব্যবহার করব। আমি ঠিক 333 নম্বর এবং টেবিলটি পছন্দ করি: v)।
— পোটোসওয়টার
হ্যাঁ সঠিক. আমার সত্যিই এটি জানা উচিত ছিল। ই-নোটেশনটি একটি ভাসমান-পয়েন্ট ধ্রুবকটির জন্য উত্পাদনে রয়েছে, যেখানে একটি ঘোষণার জন্য একটি পূর্ণসংখ্যার প্রয়োজন হয়। বিটিডাব্লু , এটি প্রতারণামূলক হতে পারে তবে আরবান মুলারের সংস্করণের জন্য nieko.net/projects/brainfuck দেখুন । সবচেয়ে বড় লাভ হ'ল এটির ভারী ব্যবহার ||।
— লুসার droog
8

সিজেম, 75 বাইট

lq3e4Vc*@{"-<[],.+>"#"T1$T=(t T(:T; { _T=}g \0+(@T@t _T=o "_'(')er+S/=}%s~@

অনলাইনে এটি ব্যবহার করে দেখুন: স্ট্রিং রিভারসার , হ্যালো ওয়ার্ল্ড ।

ব্যাখ্যা

STDIN এর প্রথম লাইনে কোড নেয় এবং এর নীচে সমস্ত লাইনে ইনপুট দেয়।

l            Read a line from STDIN (the program) and push it.
 q           Read the rest of STDIN (the input) and push it.
  3e4Vc*     Push a list of 30000 '\0' characters.
        @    Rotate the stack so the program is on top.

{               }%   Apply this to each character in prog:
 "-<[],.+>"#         Map '-' to 0, '<' to 1, ... and everything else to -1.
            ...=     Push a magical list and index from it.

s~       Concatenate the results and evaluate the resulting string as CJam code.
  @      Rotate the top three elements again -- but there are only two, so the
         program terminates.

সেই ম্যাজিকাল লিস্টের কী হবে?

"T1$T=(t T(:T; { _T=}g \0+(@T@t _T=o "  Space-separated CJam snippets.
                                        (Note the final space! We want an empty
                                        string at the end of the list.)
_'(')er+                                Duplicate, change (s to )s, append.
        S/                              Split over spaces.

ফলাফলের তালিকাটি নিম্নরূপ:

T1$T=(t    (-)
T(:T;      (<)
{          ([)
_T=}g      (])
\0+(@T@t   (,)
_T=o       (.)
T1$T=)t    (+)
T):T;      (>)
{          (unused)
_T=}g      (unused)
\0+(@T@t   (unused)
_T=o       (unused)
           (all other characters)

আমরা বাম পেরেন (সিজামের "হ্রাস") ডান পেরেন (সিজেমের "বর্ধন") এ পরিবর্তন করে এবং তাদের জন্য +এবং এর >থেকে স্নিপেট তৈরি করি ।-<

— লিন
সূত্র
সংক্ষিপ্ত উত্তর এবং বৃহত্তম বিজয়ী
— জ্যাক গিফিন
7

এফ #: 489 অক্ষর

নিম্নলিখিত প্রোগ্রামটি '[' / ']' নির্দেশাবলীতে ঝাঁপ দেয় না, তবে পরবর্তী ম্যাচের টোকেনের জন্য উত্স কোডটি স্ক্যান করে। অবশ্যই এটি এ ধরণের ধীর করে তোলে তবে এটি 100 এর নিচে প্রাইমগুলি খুঁজে পেতে পারে F

সংক্ষিপ্ত সংস্করণটি এখানে:

[<EntryPoint>]
let M a=
 let A,B,i,p,w=Array.create 30000 0uy,[|yield!System.IO.File.ReadAllText a.[0]|],ref 0,ref 0,char>>printf"%c"
 let rec g n c f a b=if c then f i;if B.[!i]=a then g(n+1)c f a b elif B.[!i]=b then(if n>0 then g(n-1)c f a b)else g n c f a b
 while !i<B.Length do(let x=A.[!p]in match B.[!i]with|'>'->incr p|'<'->decr p|'+'->A.[!p]<-x+1uy|'-'->A.[!p]<-x-1uy|'.'->w x|','->A.[!p]<-byte<|stdin.Read()|'['->g 0(x=0uy)incr '['']'|']'->g 0(x>0uy)decr ']''['|_->());incr i
 0

একটি বাজে গোচাচা হ'ল প্রাইমস.বিএফ প্রোগ্রামটি উইন্ডোজের নতুন লাইনে চিপ দেয়। এটি চালানোর জন্য আমাকে ইনপুট নম্বরটি ইউনিক্স ফর্ম্যাটেড টেক্সট ডকুমেন্টে সংরক্ষণ করতে হয়েছিল এবং একটি পাইপ দিয়ে প্রোগ্রামটিতে এটি ফিড করতে হয়েছিল:

interpret.exe prime.bf < number.txt

সম্পাদনা করুন: Alt + 010 প্রবেশ করা এর পরে প্রবেশ করুন উইন্ডোতেও কাজ করে সেমিডি.এক্সেতে

এখানে দীর্ঘ সংস্করণ:

[<EntryPoint>]
let Main args =
    let memory = Array.create 30000 0uy
    let source = [| yield! System.IO.File.ReadAllText args.[0] |]
    let memoryPointer = ref 0
    let sourcePointer = ref 0
    let outputByte b = printf "%c" (char b)
    let rec scan numBraces mustScan adjustFunc pushToken popToken =
        if mustScan then
            adjustFunc sourcePointer
            if source.[!sourcePointer] = pushToken then
                scan (numBraces + 1) mustScan adjustFunc pushToken popToken
            elif source.[!sourcePointer] = popToken then
                if numBraces > 0 then scan (numBraces - 1) mustScan adjustFunc pushToken popToken
            else
                scan numBraces mustScan adjustFunc pushToken popToken 

    while !sourcePointer < source.Length do
        let currentValue = memory.[!memoryPointer]
        match source.[!sourcePointer] with
            | '>' -> incr memoryPointer
            | '<' -> decr memoryPointer
            | '+' -> memory.[!memoryPointer] <- currentValue + 1uy
            | '-' -> memory.[!memoryPointer] <- currentValue - 1uy
            | '.' -> outputByte currentValue
            | ',' -> memory.[!memoryPointer] <- byte <| stdin.Read()
            | '[' -> scan 0 (currentValue = 0uy) incr '[' ']'
            | ']' -> scan 0 (currentValue > 0uy) decr ']' '['
            |  _  -> ()
        incr sourcePointer
    0
— cfern
সূত্র
আমি এন্টার টিস্যু টিপে চাপ না দিয়ে সমাধান করেছি, Ctrl + J :-)
— জোয়
Ctrl + J আমার পক্ষে কাজ করেনি, তবে Alt + 010 প্রবেশ করার পরে প্রবেশ করিয়েছে।
— Cfern
7

ডেলফি, 397 382 378 371 366 364 328 টি অক্ষর

এই ডেলফি খাও!

328 var p,d:PByte;f:File;z:Word=30000;x:Int8;begin p:=AllocMem(z+z);d:=p+z;Assign(F,ParamStr(1));Reset(F,1);BlockRead(F,p^,z);repeat z:=1;x:=p^;case x-43of 1:Read(PChar(d)^);3:Write(Char(d^));0,2:d^:=d^+44-x;17,19:d:=d+x-61;48,50:if(d^=0)=(x=91)then repeat p:=p+92-x;z:=z+Ord(p^=x)-Ord(p^=x xor 6);until z=0;end;Inc(p)until x=0;end.

এখানে একই কোড, ইন্ডেন্টেড এবং মন্তব্য করা হয়েছে:

var
  d,p:PByte;
  x:Int8;
  f:File;
  z:Word=30000;
begin
  // Allocate 30000 bytes for the program and the same amount for the data :
  p:=AllocMem(z+z);
  d:=p+z;
  // Read the file (which path must be specified on the command line) :
  Assign(F,ParamStr(1));
  Reset(F,1);
  BlockRead(F,p^,z);
  // Handle all input, terminating at #0 (better than the spec requires) :
  repeat
    // Prevent a begin+end block by preparing beforehand (values are only usable in '[' and ']' cases) :
    z:=1;                       // Start stack at 1
    x:=p^;                      // Starting at '[' or ']'
    // Choose a handler for this token (the offset saves 1 character in later use) :
    case x-43of
      1:Read(PChar(d)^);        // ','     : Read 1 character from input into data-pointer
      3:Write(Char(d^));        // '.'     : Write 1 character from data-pointer to output
      0,2:d^:=d^+44-x;          // '+','-' : Increase or decrease data
      17,19:d:=d+x-61;          // '<','>' : Increase or decrease data pointer
      48,50:                    // '[',']' : Start or end program block, the most complex part :
        if(d^=0)=(x=91)then     // When (data = 0 and forward), or when (data <> 0 and backward)
        repeat                  //
          p:=p+92-x;            // Step program 1 byte back or forward
          z:=z+Ord(p^=x)        // Increase stack counter when at another bracket
              -Ord(p^=x xor 6); // Decrease stack counter when at the mirror char
        until z=0;              // Stop when stack reaches 0
    end;
    Inc(p)
  until x=0;
end.

এটি আমার কয়েক ঘন্টা সময় নিয়েছিল, কারণ এটি সাধারণত আমি লিখি না এমন কোড নয়, তবে উপভোগ করুন!

দ্রষ্টব্য: প্রাইম টেস্টটি কাজ করে, তবে 100 এ থামে না, কারণ এটি # 10 (এলএফ) এর আগে # 13 (সিআর) পড়ে ... সিআরএলএফ ওএসে চলাকালীন কি অন্যান্য সাবমিশনগুলিও এই সমস্যায় পড়ে?

— PatrickvL
সূত্র
কি দারুন! আমি কখনই ডেলফির সাথে সি ট্রাম্প করার আশা করতাম না! আপনি সিআই অনুমানের উপর আমার ধারণাগুলি প্রয়োগ না করা পর্যন্ত নয় ;-)
— প্যাট্রিকভিএল
7

সি, 260 + 23 = 283 বাইট

আমি একটি সি প্রোগ্রাম তৈরি করেছি যা এখানে পাওয়া যাবে ।

main(int a,char*s[]){int b[atoi(s[2])],*z=b,p;char*c=s[1],v,w;while(p=1,
*c){q('>',++z)q('<',--z)q('+',++*z)q('-',--*z)q('.',putchar(*z))q(',',*z
=getchar())if(*c=='['||*c==']'){v=*c,w=184-v;if(v<w?*z==0:*z!=0)while(p)
v<w?c++:c--,p+=*c==v?1:*c==w?-1:0;}c++;}}

এর মাধ্যমে সংকলন gcc -D"q(a,b)"="*c-a||(b);" -o pmmbf pmmbf.cকরতে হবে এবং নিম্নলিখিত হিসাবে বলা যেতে পারে: pmmbf ",[.-]" 30000যার মাধ্যমে প্রথম যুক্তিতে (উদ্ধৃত) চলমান বিএফ-প্রোগ্রাম রয়েছে, দ্বিতীয়টি নির্ধারণ করে যে টেপটি কত বড় হওয়া উচিত।

— phimuemue
সূত্র
1
আমি মনে করি যে -D"q(a,b)"="*c-a||(b);"বিকল্পটির জন্য আপনার গণনায় 23 টি অক্ষর যুক্ত করা দরকার , যেহেতু মনে হচ্ছে (কোডটি কমপক্ষে আমার সীমাবদ্ধ বোঝার জন্য) আপনাকে আপনার কোড সঙ্কুচিত করতে সহায়তা করবে।
— গ্যারেথ
বিকল্পটি পোস্ট করা লেখায় অন্তর্ভুক্ত রয়েছে। এর কারণটি হ'ল দীর্ঘ শব্দ defineএবং নিউলাইনটি এড়ানো , তবে আমি মনে করি না এটি সত্যিই কোশার। যাইহোক, উদ্ধৃতি, মন্তব্য সহ, এবং gcc -Dআমি সুবিধাটি মোটেই দেখছি না।
— আলু
5

সি, 267

#define J break;case
char*p,a[40000],*q=a;w(n){for(;*q-93;q++){if(n)switch(*q){J'>':++p;J'<':--p;J'+':++*p;J'-':--*p;J'.':putchar(*p);J',':*p=getchar();}if(*q==91){char*r=*p&&n?q-1:0;q++;w(r);q=r?r:q;}}}main(int n,char**v){p=a+read(open(v[1],0),a,9999);*p++=93;w(1);}

./A.out primes.bf হিসাবে চালান

অবরুদ্ধ সংস্করণ:

#define J break;case

char*p,a[40000],*q=a; // packed so program immediately followed by data

w(n){
    for(;*q-93;q++){ // until ']'
        if(n)switch(*q){ // n = flagged whether loop evaluate or skip(0)
                J'>':++p;
                J'<':--p;
                J'+':++*p;
                J'-':--*p;
                J'.':putchar(*p);
                J',':*p=getchar();
        }
        if(*q==91){char*r=*p&&n?q-1:0;q++;w(r);q=r?r:q;} // recurse on '[', record loop start
    }
}

main(int n,char**v){
    p=a+read(open(v[1],0),a,9999);
    *p++=93; // mark EOF with extra ']' and set data pointer to next
    w(1); // begin as a loop evaluate
}
— বাচ্চা খরগোস
সূত্র
5

পাইথন 2, 223

আমি স্বীকার করি যে আমি আমার একটি পুরানো প্রোগ্রাম পুনর্ব্যবহার করেছি (তবে এটি বেশ খানিকটা পরিবর্তন করতে হয়েছিল, কারণ পুরানো সংস্করণে ইনপুট ছিল না, তবে ত্রুটি পরীক্ষা করার ক্ষেত্রে ...)।

P="";i,a=0,[0]*30000
import os,sys
for c in open(sys.argv[1]).read():x="><+-.[,]".find(c);P+=" "*i+"i+=1 i-=1 a[i]+=1 a[i]-=1 os.write(1,chr(a[i])) while+a[i]: a[i]=ord(os.read(0,1)) 0".split()[x]+"\n";i+=(x>4)*(6-x)
exec P

প্রাইমস ক্যালকুলেটর জরিমানা চালায়।

আমি এখন দেখতে পাচ্ছি যে আলেকজান্দ্রুর একটি উত্তর রয়েছে যার কিছু মিল রয়েছে। আমি যাই হোক না কেন মনি উত্তর পোস্ট করব, কারণ আমি মনে করি এটিতে কিছু নতুন ধারণা রয়েছে।

— WolframH
সূত্র
5

সি (জিসিসি) লিনাক্স x86_64, 884 621 525 487 439 383 358 354 বাইট

*z,*mmap();d[7500];(*p)();*j(a,g)char*a;{char*t=a,*n,c,q=0;for(;read(g,&c,!q);)t=c==91?n=j(t+9,g),z=mempcpy(t,L"\xf003e80Ƅ",5),*z=n-t-9,n:c==93?q=*t++=233,z=t,*z=a-13-t,z+1:stpcpy(t,c-62?c-60?c-43?c-45?c-46?c-44?"":"1\xc0P_\xF\5":"RXR_\xF\5":L"໾":L"۾":L"컿":L"웿");return t;}main(P,g)int**g;{p=mmap(0,1<<20,6,34,0,0);p(*j(p,open(g[1],0))=195,d,1);}

এটি অনলাইন চেষ্টা করুন!

এটি একটি জেআইটি যা রানটাইমের সময় বিএফ কোডটি x86_64 মেশিন ল্যাঙ্গুয়েজে সংকলন করে। এটি একটি সরল অনুবাদ সম্পাদন করে যাতে সাধারণত , এবং >>>, এর মতো ক্রম হয়<<<+++--- দ্রুততর নির্দেশাবলী মধ্যে coalesced নেই।

কম গল্ফ সংস্করণ:

// size of data area
*z,c,*mmap();d[7500];(*p)();
// recursive function translates BF commands to x86_64 instructions
*j(a,g)char*a;{
  char*t=a,*n,q=0;
  for(;read(g,&c,!q);)
    t=c==91? // [
        // cmpb $0x0,(%rsi)
        // je n-t-9
        n=j(t+9,g),
        z=mempcpy(t,L"\xf003e80Ƅ",5)
        *z=n-t-9,
        n
      :
        c==93? // ]
          // jmp a-13-t
          q=*t++=233,
          z=t,
          *z=a-13-t,
          z+1
        :
          stpcpy(t,c-62? // >
                     c-60? // <
                       c-43? // +
                         c-45? // -
                           c-46? // .
                             c-44? // ,
                               ""
                             :
                               // xor %eax,%eax
                               // push %rax
                               // pop %rdi
                               // syscall
                               "1\xc0P_\xF\5"
                           :
                             // push %rdx
                             // pop %rax
                             // push %rdx
                             // pop %rdi
                             // syscall
                             "RXR_\xF\5"
                         :
                           // decb (%rsi)
                           L"໾"
                       :
                         // incb (%rsi)
                         L"۾"
                     :
                       // dec %esi
                       L"컿"
                   :
                     // inc %esi
                     L"웿");
  return t;
}
main(P,g)int**g;{
  // allocate text (executable) memory and mark as executable
  p=mmap(0,1<<20,6,34,0,0);
  // run JIT, set %rdx=1 and call code like a function
  p(*j(p,open(g[1],0))=195,d,1);
}
— ceilingcat
সূত্র
4

সি, 374 368

একটি ফাইল থেকে পড়া। PRIME.BF পরীক্ষা পাস করে।

ব্যবহার: ./a.out PRIME.BF

#include <stdio.h>
main(int c,char**v){int m[30000],s[99],p=0,i=0,n=0;char l[9999],d;FILE*f=fopen(v[1],"r");for(l[i]=0;i<9999&&l[i]!=EOF;l[i]=getc(f))i++;for(i=1;d=l[i];i++){if(!n){p+=d-62?0:1;p-=d-60?0:1;m[p]+=d-43?0:1;m[p]-=d-45?0:1;if(d==46)putchar(m[p]);if(d==44){m[p]=getchar();}if(d==93){i=s[c]-1;c--;n++;}}if(d==91){if(m[p]){c++;s[c]=i;}else{n++;}}n-=d-93?0:1;}}


ফরম্যাট:

#include <stdio.h>
main(int c,char**v){
    int m[3000],s[99],p=0,i=0,n=0;
    char l[9999],d;
    FILE*f=fopen(v[1],"r");
    for(l[i]=0;i<9999&&l[i]!=EOF;l[i]=getc(f))i++;
    for(i=1;d=l[i];i++){
        if(!n){ // > < + - . , ] \n [ ]
            p+=d-62?0:1;
            p-=d-60?0:1;
            m[p]+=d-43?0:1;
            m[p]-=d-45?0:1;
            if(d==46)putchar(m[p]);
            if(d==44){m[p]=getchar();}
            if(d==93){i=s[c]-1;c--;n++;}
        }
        if(d==91){if(m[p]){c++;s[c]=i;}else{n++;}}
        n-=d-93?0:1;
    }
}
— jtjacques
সূত্র
3000 বনাম 30000. আপনার বাফারটি খুব ছোট। প্রোগ্রামের আকারও খুব ছোট।
— আলেকজান্দ্রু
আমি একটি টাইপো তৈরি করেছি, স্থির করেছি। আপনি প্রোগ্রাম আকার বলতে কি বোঝাতে চান? আপনি যদি সর্বোচ্চ ফাইলের আকার বলতে চান, আপনি এটি পরিচালনা করতে চান এমন কোনও ন্যূনতম নির্দিষ্ট করে নি।
— jtjacques
4

লুয়া, 285

loadstring("m,p={0},1 "..io.open(arg[1]):read"*a":gsub("[^.,<>[%]+-]",""):gsub(".",{["."]="io.write(string.char(@)) ",[","]="@=io.read(1):byte() ",["<"]="p=p-1 ",[">"]="p=p+1 @=@or 0 ",["["]="while @~=0 do ",["]"]="end ",["+"]="@=(@+1)%256 ",["-"]="@=(@-1)%256 "}):gsub("@","m[p]"))()

কিছুটা পঠনযোগ্য সংস্করণ:

loadstring( --execute
    "m,p={0},1 ".. --initialize memory and pointer
    io.open(arg[1]) --open file
        :read"*a" --read all
            :gsub("[^.,<>[%]+-]","") --strip non-brainfuck
                :gsub(".", --for each character left
                    {["."]="io.write(string.char(@)) ", -- '@' is shortcut for 'm[p]', see below
                    [","]="@=io.read(1):byte() ",
                    ["<"]="p=p-1 ",
                    [">"]="p=p+1 @=@or 0 ", --if a before unexplored memory cell, set to 0
                    ["["]="while @~=0 do ",
                    ["]"]="end ",
                    ["+"]="@=(@+1)%256 ", --i like it overflowing
                    ["-"]="@=(@-1)%256 "
                    }
                )
                    :gsub("@","m[p]") --replace the '@' shortcut
    ) --loadstring returns a function
() --call it

পুরোপুরি কাজ করে

লুয়া, 478, ডাব্লু / ও লোডস্ট্রিং

local m,p,i,r,c={0},1,1,{},io.open(arg[1]):read"*a"while i<=#c do(({[43]=function()m[p]=(m[p]+1)%256 end,[45]=function()m[p]=(m[p]-1)%256 end,[62]=function()p=p+1 m[p]=m[p]or 0 end,[60]=function()p=p-1 end,[46]=function()io.write(string.char(m[p]))end,[44]=function()m[p]=io.read(1):byte()end,[91]=function()if m[p]==0 then i=select(2,c:find("%b[]",i))else r[#r+1]=i end end,[93]=function()if m[p]==0 then r[#r]=nil else i=r[#r] end end})[c:byte(i)]or function()end)()i=i+1 end

পঠনযোগ্য সংস্করণ:

local m,   p, i, r,  c= --memory, pointer, brackets stack, code
      {0}, 1, 1, {}, io.open(arg[1]) --open file
              :read"*a" --read it
while i<=#c do --while there's code
    (
        (
            {
                [43]=function() -- +
                    m[p]=(m[p]+1)%256
                end,
                [45]=function() -- -
                    m[p]=(m[p]-1)%256
                end,
                [62]=function() -- >
                    p=p+1 m[p]=m[p]or 0 --if new memory cell, set it to 0
                end,
                [60]=function() -- <
                    p=p-1
                end,
                [46]=function() -- .
                    io.write(string.char(m[p]))
                end,
                [44]=function() -- ,
                    m[p]=io.read(1):byte()
                end,
                [91]=function() -- [
                    if m[p]==0 then
                        i=select(2,c:find("%b[]",i)) --find matching ]
                    else
                        r[#r+1]=i --push position to the stack
                    end
                end,
                [93]=function() -- ]
                    if m[p]==0 then
                        r[#r]=nil --pop from stack
                    else
                        i=r[#r] --go to position on the top of stack
                    end
                end
            }
        )[c:byte(i)] --transform character into code
        or function()end --do nothing on non-brainfuck
    )() --run the resulting function
    i=i+1 --go to the next opcode
end
— mniip
সূত্র
4

ব্রেইনফাক, 948 বাইট

ঠিক আছে, এটি একটি সময় লাগল। আমি ব্রেইনফাকের একজন স্ব-দোভাষীকে গল্ফ দিয়েছি ... আমার দ্বারা নয়।

->->>>-[,+>+<[->-]>[->]<+<-------------------------------------[+++++++++++++++++++++++++++++++++++++>-]>[->]<<[>++++++++[-<----->]<---[-[-[-[--------------[--[>+++++++[-<---->]<-[--[[+]->]<+[->++>]->]<+[->+>]->]<+[->+++++>]->]<+[->++++++>]->]<+[->+++++++>]->]<+[->++++>]->]<+[->++++++++>]->]<+[->+++>]->]+<+[->->]>[-<->]<]>>->>-<<<<<+++[<]>[-[-[-[-[-[-[-[-<<++++++++>>>[>]>>>>+[->>+]->,<<<+[-<<+]-<<<[<]<]>[<<<+++++++>>>[>]>>>>+[->>+]->.<<<+[-<<+]-<<<[<]]<]>[<<<++++++>>>[>]>>>>+[->>+]<<-<<+[-<<+]-<<<[<]]<]>[<<<+++++>>>[>]>>>>+[->>+]+>>-<<[-<<+]-<<<[<]]<]>[<<<++++>>>[>]>>>>+[->>+]->-<<<+[-<<+]-<<<[<]]<]>[<<<+++>>>[>]>>>>+[->>+]->+<<<+[-<<+]-<<<[<]]<]>[<++[>]>>>>+[->>+]->[<<<+[-<<+]-<<<[<]-[<<-[>->-[<+]]<+[->>[<]]<-[>-->+[<++]]<++[-->>[<]]<++>>[[-<+>]<<[->>+<<]]<[>]>]]<[<<+[-<<+]-<<<[<]>--<<++>]>]<]>[<<<+>>>[>]>>>>+[->>+]->[<<<+[-<<+]-<<<[<]]<[<<+[-<<+]-<<<[<]+[>-[<-<]<<[>>]>>-[<+<]<<[>>]>>++<[>[-<<+>>]<[->+<]]<[>]>]]>[[-<<+>>]<[->+<]>]]>]
— এমডি এক্সএফ
সূত্র
4

প্রত্যাহার করুন , 594 বাইট

সংক্ষেপে: রিকালটির কোনও গাণিতিক অপারেটর ক্লাসিক অর্থে নেই, এটি কেবল বিটওয়াইস অপারেশন করে has আপনি কেবল "একটি যোগ করুন" ইত্যাদি করতে পারবেন না Rec পুনরুদ্ধারটি কঠোরভাবে স্ট্যাক-ভিত্তিক।

DC505M22022M32032M606M42042M707M92092M4405022o032o06o042o07o092o044o1305022o06o042o092o52052q.q2305022o06o07o93093q.q5403206o07o14014q.q6403206o042o07o24024q.q74Yx34034z03MMMMMMMM034o3yY030401r3.4.101zyY040301r4.3.101zY01052gZ02Z040301052023s4.3.10zyY01023gZ02z030401023052s3.4.10zyY01093gZ02q20zyY01054gZ02u20zyY01014gZx20zyY01064gZ02X0zyY01024gZ03304302r33.43.20zyY01074gZ04303302r43.33.20zyyQ6205.8Y06208g6206208iZ08M808013izy062U7205.9Y07209g7207209iz09M909013izy072R53.63.82063MMMMMMMM053o63082013i53082KKKKKKKK82053063082S84.94.12.73.83t012073083TY083073012r83.73.12012084gzY012094gZt0zyy

উদাহরণ 1: কিছু মুদ্রণ করুন

ইনপুট:

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

আউটপুট:

PPCG rocks!

উদাহরণ 2: 100 পর্যন্ত আউটপুট বর্গ সংখ্যা

ইনপুট:

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

আউটপুট:

0
1
4
9
16
25
36
49
64
81
100

এই উদাহরণটি কার্যকর করতে কয়েক মিনিট সময় নিতে পারে এবং "এই ট্যাবটি হিমশীতল" বার্তাটির কারণ হতে পারে। এটি উপেক্ষা করুন এবং অপেক্ষা করুন।

— mınxomaτ
সূত্র
4
আপনার ওয়েবসাইট ডোমেনের মেয়াদ শেষ হয়ে গেছে। এছাড়াও, এই উত্তরটি প্রতিযোগিতামূলক নয়, কারণ ভাষা চ্যালেঞ্জের চেয়ে নতুন new
— mbomb007
3

ওসিএএমএল (লেক্স), 497 অক্ষর

ওক্যামল্লেক্স ওসিএএমএল এর স্ট্যান্ডার্ড বিতরণের একটি অংশ।

{let a=Array.create 30000 0
let(%)f g h=f(g h)
let s v i=a.(i)<-v;i
let o d i=s(a.(i)+d)i
let p i=print_char(Char.chr a.(i));flush stdout;i
let r i=s(Char.code(input_char stdin))i
let rec w g i=if 0=a.(i)then i else w g(g i)
let n x=x}
rule t f=parse
|'>'{t(succ%f)lexbuf}
|'<'{t(pred%f)lexbuf}
|'+'{t((o 1)%f)lexbuf}
|'-'{t((o(-1))%f)lexbuf}
|'.'{t(p%f)lexbuf}
|','{t(r%f)lexbuf}
|'['{t((w(t n lexbuf))%f)lexbuf}
|']'|eof{f}
|_{t f lexbuf}
{let _=t n(Lexing.from_channel(open_in Sys.argv.(1)))0}

B.mll হিসাবে সংরক্ষণ করুন এবং সাথে চালানো

ocamllex b.mll && ocaml b.ml prime.bf

আমি হাত দিয়ে পার্সিং পছন্দ করি না, তাই আমি সরবরাহিত লেক্সার জেনারেটরটি ব্যবহার করেছি। টোকেনগুলি পড়া থেকে, আমরা পুরো ব্রেইনফ * সিকে প্রোগ্রামের জন্য একটি ফাংশন রচনা করি।

— bltxd
সূত্র
3

সি # (2861 চর, ~ 84 লাইন)

এটি সমস্যার প্রাকৃতিক সমাধান নয় এবং সম্ভবত 'গল্ফ-ইশ' নয়, যেহেতু আমার দৈর্ঘ্যের বিষয়ে যতটা উদ্বিগ্ন ছিল না, সম্ভবত আমারও হওয়া উচিত ছিল। (আমি মন্তব্যগুলি বা অতিরিক্ত সাদা স্থান সরিয়ে ফেলিনি)) আমি কেবল নতুন ভাষায় কিছু চেষ্টা করতে চেয়েছিলাম, আমি দেখতে পারছি কিনা তা দেখার জন্য। আমি যদি আবার এটি করি তবে আমি ']' থেকে ফিরে আসার জন্য স্ট্যাকের ব্যবহারটি ফেলে দেব এবং কেবল ফিরে ফিরে তাকাব। কমান্ড লাইন আর্গুমেন্ট ছাড়াই চালান এটি সমস্যার বর্ণনায় প্রদত্ত হ্যালো ওয়ার্ল্ড প্রোগ্রামটি চালায়। এটি একটি কমান্ড লাইন আর্গুমেন্ট গ্রহণ করে, প্রোগ্রাম চালানোর জন্য ফাইলের নাম।

using System;
using System.Collections.Generic;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            String ProgSource;
            if (args.Length > 0)
                ProgSource = System.IO.File.ReadAllText(args[0]);
            else //hello world
                ProgSource = "";

            Stack<int> stack = new Stack<int>();
            char[] bfProg = ProgSource.ToCharArray();
            char[] mem = new char[30000];
            int ptr = 0;

            for (int ip = 0; ip<bfProg.Length; ip++){
                switch (bfProg[ip])
                {
                    case ('>'): ptr++;  break;
                    case ('<'): ptr--;  break;
                    case ('+'): mem[ptr]++; break;
                    case ('-'): mem[ptr]--; break;
                    case ('.'): Console.Write(mem[ptr]); break;
                    case (','): 
                        char key = Console.ReadKey(false).KeyChar;
                        if (key == '\r')
                        {
                            key = (char)10;
                            Console.WriteLine();
                        }
                        mem[ptr] = key;
                        break;
                    case ('['):
                        if (mem[ptr] == 0)
                        {
                            int openBraces = 1;
                            //find the closing brace for this expression
                            for (int x = 1; x < (bfProg.Length - ip); x++)
                            {
                                if (bfProg[ip + x] == ']') openBraces--;
                                if (bfProg[ip + x] == '[') openBraces++;
                                if (openBraces == 0)
                                {
                                    if (stack.Peek() == ip) stack.Pop();
                                    ip += x;
                                    break;
                                }                                
                            }
                       }
                       else
                       {
                           stack.Push(ip);
                       }
                       break;
                    case (']'):
                        if (mem[ptr] == 0)
                            stack.Pop();
                        else
                        {
                            ip = stack.Peek();
                        }
                        break;
                }
            }

            Console.WriteLine("\n\n\nExecution Completed Sucessfully. Press any key to continue...");
            Console.ReadKey();

        }
    }

}

সম্পাদনা: অব্যবহৃত উল্লেখগুলি সরানো হয়েছে।

— theB
সূত্র
1
@ mbomb007 - আপডেট হয়েছে। পুরোপুরি ভুলে গিয়েছিলাম এমনকি আমি এটিও করেছি। (এমনকি কেউ এই পুরানো প্রশ্নগুলি
— পড়েও
লোকেরা কেবল সেগুলি এখনও পড়ে না, তারা এখনও উত্তর দেয় এবং গল্ফ করে।
— mbomb007
3

সি (জিসিসি) , 273 268 বাইট

main(_,a){_=fopen("w.c","w");fputs("main(){char a[30000],*p=a;",_);x:a=getchar();fputs(a-62?a-60?a-43?a-45?a-46?a-44?a-91?a-93?~a?"":"}":"}":"while(*p){":"*p=getchar();":"putchar(*p);":"--*p;":"++*p;":"--p;":"++p;",_);if(~a)goto x;fclose(_);system("cc w.c;./a.out");};

এটি অনলাইন চেষ্টা করুন!

-5 সিলিংক্যাট ধন্যবাদ

স্টিডিন থেকে ইনপুট নেয়।

এটি পরিবেশের উপর খানিকটা নির্ভর করে তবে বেশ সামঞ্জস্যপূর্ণ। এটি কার্যকরভাবে গ এর জন্য বিচ্ছিন্ন সমাধান। এটি ডাব্লুসিসি ফাইলটিতে একটি উপযুক্ত সি প্রোগ্রাম লিখেছে, এটি সংকলন করে এবং এটি পছন্দসই নির্বাহযোগ্য হিসাবে চালিত করে। সুতরাং বোনাস প্রভাব হিসাবে এটি আসলে বিএফ কোডটি সংকলন করে এবং এর a.outজন্য বাইনারি হিসাবে ছেড়ে যায়। নোট করুন যে সিস্টেমের উপর নির্ভর করে আপনাকে শেষ স্ট্রিংটি সংশোধন করতে হবে। বিশেষত বেশিরভাগ উইন্ডোজ সি সংকলকরা ডিফল্টকে নির্বাহযোগ্য "a.exe" বলে। ভাগ্যক্রমে আমি যতদূর বলতে পারি, তাদের সকলের দৈর্ঘ্য একই তাই বাইটোক্যান্ট একই। (যদিও আপনার যদি সিসি সংজ্ঞায়িত না হয় তবে আপনাকে কমপাইল কমান্ডে একটি ব্রেস যুক্ত করতে হবে, যেমন 1 কম বাইট যোগ করে) command

আমি সচেতন যে এই থ্রেডটি কিছুটা পুরানো, তবে আমি এখনও সি সমাধানের এই স্টাইলটি দেখতে পাইনি, তাই আমি ভেবেছিলাম আমি এটি যুক্ত করব।

— LambdaBeta
সূত্র
— সিলিংক্যাট
2

[Edit]

সি ++ 11, 355, ফাইল থেকে পড়ে:

#include<functional>
#include<stdio.h>
main(){
char b[30000],g[9999],*f=g,*p=b,n[]="+-,.><[]",j;
std::function<void()>m[]={
[&p]{(*p)++;},
[&p]{(*p)--;},
[&p]{*p=getchar();},
[&p]{putchar(*p);},
[&p]{p++;},
[&p]{p--;},
[&p,&f]{if(!(*p))while(*f-93)f++;},
[&f,&m]{while(*f-91)f--;m[6]();}
};
fread(g,1,9999,fopen(a[1],0));
for(;*f;f++)for(j=0;n[j];j++)if(n[j]==*f)m[j]();
}

পরীক্ষা

http://ideone.com/b7vO4

[পুরাতন রুপ]

চলমান দেখতে সি ++ 11, 391,: http://ideone.com/yZHVv

#include<functional>
#include<stdio.h>
main(int c,char **a) {
  char b[30000],g[9999],*f=g,*r=f,*p=b;
  std::function<void()>m[256];
  m['>']=[&p]{p++;};  
  m['<']=[&p]{p--;};
  m['+']=[&p]{(*p)++;};
  m['-']=[&p]{(*p)--;};
  m['.']=[p]{putchar(*p);};
  m[',']=[&p]{*p=getchar();};
  m['[']=[p,&r,&f]{*p?r=f-1:r=0;};
  m[']']=[&r,&f]{r?f=r:r=f;};
  fread(g,1,9999,fopen(a[1],"r"));
  while (c=*(f++))if(m[c]&&(r||c==']'))m[c]();
}
— olivecoder
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.