এই চ্যালেঞ্জটিতে আপনি যে সহজ ভাষাটি তৈরি করেছি তার জন্য একজন অনুবাদক লিখতে চলেছেন। ভাষাটি একটি একক সংগ্রহকারী এ এর উপর ভিত্তি করে, দৈর্ঘ্যে হুবহু এক বাইট। প্রোগ্রামের শুরুতে, A = 0 এ ভাষাগুলির নির্দেশাবলী:

`!`: বিপর্যয়

এই নির্দেশিকাটি কেবল সঞ্চয়ের প্রতিটি বিটকে উল্টে দেয়। প্রতিটি শূন্য এক হয়ে যায় এবং প্রতিটি শূন্য হয়ে যায়। সরল!

`>`: শিফট ডানদিকে

এই নির্দেশিকাটি প্রতিটি জায়গায় এক জায়গায় ডান দিকে সরে যায়। বামতম বিটটি শূন্য হয়ে যায় এবং ডানদিকের বিটটি ফেলে দেওয়া হয়।

`<`: শিফট বাম

এই নির্দেশটি প্রতিটি স্থানে এক জায়গায় বামে স্থানান্তরিত করে। ডানদিকের বিটটি শূন্য হয়ে যায় এবং বামদিকের বিটটি ফেলে দেওয়া হয়।

`@`: নেব্বলগুলি অদলবদল করুন

এই নির্দেশটি নীচের চারটি বিট সহ এ এর শীর্ষ চারটি বিটকে অদলবদল করে। উদাহরণস্বরূপ, যদি A হয় 01101010এবং আপনি কার্যকর করেন তবে @A হবে 10100110:

 ____________________
 |                  |
0110 1010    1010 0110
      |_______|

এটাই সব নির্দেশ! সরল, তাই না?

বিধি

আপনার প্রোগ্রামের শুরুতে একবার ইনপুট গ্রহণ করতে হবে । এটি কোডের একটি লাইন হবে। এই না একটি ইন্টারেক্টিভ অনুবাদক! আপনি কেবল একবার ইনপুট গ্রহণ করতে পারেন এবং একবার লাইনটি কার্যকর হয়ে গেলে আবার শুরুতে লুপ করতে হবে না।
আপনার প্রোগ্রাম অবশ্যই ইনপুট মূল্যায়ন করতে হবে। উপরে বর্ণিত প্রতিটি চরিত্র উপেক্ষা করা হয়।
আপনার প্রোগ্রামটির পরে দশমিক হিসাবে সঞ্চয়ের শেষ চূড়ান্ত মানটি মুদ্রণ করা উচিত।
বৈধ প্রোগ্রামিং ভাষার জন্য সাধারণ নিয়ম প্রযোজ্য।
স্ট্যান্ডার্ড লুফোলগুলি অনুমোদিত নয়।
এটি কোড-গল্ফ , ক্ষুদ্রতম বাইট গণনা জয়।

আপনার জমাগুলি পরীক্ষা করার জন্য এখানে কয়েকটি ছোট প্রোগ্রাম রয়েছে। তীরটি কোড হওয়ার আগে এটি প্রত্যাশিত ফলাফল হওয়ার পরে:

! -> 255
!>> -> 63
!<@ -> 239
!nop!&6*! -> 255

উপভোগ করুন!

code-golf interpreter bitwise

— bitsnbites
সূত্র

আমি ধরে নিচ্ছি ! -> 255যে আমরা এখানে বাইট প্রতি 8 বিট ব্যবহার করব? প্রশ্নটি স্পষ্ট নয়।

— টবি স্পিড

3

সংজ্ঞা অনুসারে @ টবিস্পাইট এ বাইট, 8 বিট

— হাইপার নিউট্রিনো

15

পাইথ, 36 35 বাইট

u%@[t_G/G2yGi_jGJ16JG)x"!><@"H256z0

পরীক্ষার জোতা

সংগ্রহকারীর অভ্যন্তরীণ উপস্থাপনা একটি পূর্ণসংখ্যা। এই পূর্ণসংখ্যাটি প্রতিটি পুনরাবৃত্তিতে 256 দ্বারা মোড-এড করা হয়, যেমনটি পছন্দসই। সঞ্চালিত অপারেশন হয় -G-1, G/2, G*2এবং Gবেস 10, যেখানে বেস 16, বিপরীত, এবং রূপান্তরিত ফিরে রূপান্তরিত Gসঁচায়ক হয়।

আমি সমস্ত কিছু উপেক্ষা করার বিষয়ে লাইনটি মিস করেছি। এটি প্রতিকার করা হয়েছে। ধন্যবাদ, ডেনিস

— isaacg
সূত্র

তাহলে পাইথের -G-1চেয়েও খাটো ~G? আমি কিছুটা সন্দেহ করি।

— ক্যালকুলেটরফলাইন

প্রশ্নের কোডটি আসলে t_G, যেখানে _প্রত্যাশা এবং tতা -1। পাইথের ~অর্থ সম্পূর্ণ ভিন্ন কিছু।

— isaacg

আমি পাইথন বলতে চাইছি ~(বিটওয়াইস নট)

— ক্যালকুলেটরফলাইন

@ ক্যালকুলেটরফলাইন আমার বক্তব্যটি ছিল পাইথের সাথে প্রভাবটির সাথে কোনও 1-চরিত্রের ফাংশন নেই, সুতরাং উপরের কোডটি (কমপক্ষে সেই অপারেশনের জন্য) এটি যতটা ভাল পাচ্ছে ঠিক তত ভাল।

— isaacg

13

সি, 96

ধরে নিচ্ছেন ASCII (বা সামঞ্জস্যপূর্ণ) ইনপুট:

a;main(c){while(c=getchar()+1)a=(c^34?c^61?c^63?c^65?a:a*257/16:a/2:a*2:~a)&255;printf("%u",a);}

Tidier:

a;
main(c){
  while(c=getchar()+1)
    a=(c^34?
      c^61?
        c^63?
          c^65?
            a
          :
            a*257/16
        :
          a/2
      :a*2:~a
    )&255;
  printf("%u",a);
}

মূলত এটি কেবল নেস্টেড টের্নারি এক্সপ্রেশনগুলির একটি সংগ্রহ। আমি প্রাপ্ত মানটি বাড়িয়ে দিচ্ছি getchar()যাতে কোনও ইওএফ (-1) ফলাফলের শূন্য হয় এবং প্রোগ্রামটি প্রস্থান হয়।

(আদর্শ লিঙ্ক)

— চটজলদি ossifrage
সূত্র

1

আমি নিজেই চ্যালেঞ্জটি চেষ্টা করেছিলাম এবং প্রায় একই কোডটি লিখেছিলাম। BTW। উপরের দিকে সরানোর সময় আপনার প্রোগ্রামটি কিছুটা বাদ দেয় না (ইনপুট: !<>ফলাফলটি হওয়া উচিত 127এবং না 255)। হয় আপনার aহিসাবে সংজ্ঞায়িত করুন char, বা সঠিক প্রভাব পেতে লাইনটি a&=255(এবং ব্যবহার %u) ব্যবহার করুন । এছাড়াও আপনি আপনার অস্বীকৃতি খাটো করতে পারেন a^255থেকে ~a। a>>4&15আপনার থেকেও খাটো (a&240)/16।

— মার্কডেফিয়ান্ট

আহ, ভাল পয়েন্ট। দেখা যাচ্ছে যে প্রতিটি পুনরাবৃত্তিতে কম 8 টি বিটকে মাস্ক করা আরও দক্ষ।

— স্কিওমিশ ওসিফরেজ

1

এই ক্ষেত্রে আপনি এমনকি %uপরিবর্তে ফর্ম্যাট স্ট্রিংটি ব্যবহার করতে পারেন%hhu

— মারকডিফায়েন্ট

1

আমি এখন এটি দেখেছি, তবে আপনি এর a/16|a*16পরিবর্তে ব্যবহার করতে পারেন a/16|(a&15)*16। উপরের কয়েকটি বিট দ্বারা মুছে ফেলা হয় &255।

— মারকডিফায়েন্ট

1

একটি ক্ষুদ্র উন্নতি: a*257/16একাধিক বাইট খাটো a/16|a*16।

— টবি স্পিড

11

পাইথন 3, 133 বাইট

পাইথনে স্যুইচ-কেস সিনট্যাক্সের অভাব তৈরি করতে একটি অভিধান ব্যবহার করে। এখানে আরও দেখুন ।

a="0"*8
for i in input():a={"!":''.join(str(1-int(b))for b in a),"<":a[1:]+"0",">":"0"+a[:-1],"@":a[4:]+a[:4]}.get(i,a)
print(int(a,2))

সঞ্চালক একটি স্ট্রিং যা শেষে 10 বেসে রূপান্তরিত হয়।

আই / ও উদাহরণ:

$ python3 bitsnbytes.py
!
255
$ python3 bitsnbytes.py
!>>
63
$ python3 bitsnbytes.py
!<@
239
$ python3 bitsnbytes.py
!nop!&6*!
255

— বেটা ক্ষয়
সূত্র

এটি যদি সত্যিকারের, ইন্টারেক্টিভ দোভাষী হয়, তবে তা for i in sys.stdin::)

— Zizouz212

4

@ জিজোজ ২১২ আমি বিশ্বাস করি আপনার অর্থ যদি এটি ইন্টারেক্টিভ হয়; এটি আমার কাছে সত্যিকারের দোভাষীর মতো দেখাচ্ছে। ;)

— অ্যালেক্স এ।

9

জাভাস্ক্রিপ্ট (ES6), 80 91 90 বাইট

a=>[...a].reduce((p,c)=>c=='!'?p^255:c=='<'?p*2%256:c=='>'?p>>1:c=='@'?p/16|0+p%16*16:p,0)

এটি যতটা সংক্ষিপ্ত তা পেতে পারেন। একটি বেনামী ফাংশন সংজ্ঞায়িত করে যা প্রোগ্রামটিকে ইনপুট হিসাবে গ্রহণ করে।

জন্য !, গ্রহণ x XOR 255, হিসাবে জেএস এর ~বিবেচনা করবেx একটি 32-বিট সংখ্যা ।
এর জন্য <, x2 দ্বারা গুণিত হয় এবং ফলাফলটি 256 তে নেয় takes
জন্য >, সত্যই x1 বিট বিট ডান দিকে স্থানান্তরিত।
জন্য @, মেঝে x/16এবং এটি যুক্ত করে x%16*16।

reduceবাইট সংরক্ষণ করতে ব্যবহারের পরামর্শ দেওয়ার জন্য @ভিহানকে ধন্যবাদ

— ETHproductions
সূত্র

আপনি <প্রায় 4 বাইট সংরক্ষণ করতে ব্যবহার করতে পারেন । হ্রাস ব্যবহার করা কিছু বাইটগুলিও সাশ্রয় করতে পারে

— ডাউনগোট

1

@ভিহান আপনার <জায়গায় কি বোঝাতে চাইছেন ==? যদি তা হয় তবে এটি কার্যকর হবে না, কারণ কোনও অপ-অক্ষর অক্ষরগুলি ভুলভাবে একটি ক্রিয়াকলাপ সম্পাদন করবে। আমি এটি আমার আগের, 80-বাইট সমাধানে ব্যবহার করেছি।

— ইটিএইচ প্রোডাকশনস

পিপিসিজিতে ES6 ফ্যাট অ্যারো স্ট্যান্ডার্ড নয় যা আপনাকে এটি সংজ্ঞায়িত করতে হবে?

— মেয়রমন্তি

@ স্পিডিনিঞ্জা আমি এরকম কোনও মানদণ্ড সম্পর্কে জানিনা, তবে আপনি যদি আমাকে একটি পোস্টে নির্দেশ করতে পারেন তবে আমি আমার উত্তরটি পরিবর্তন করব।

— ETH প্রোডাকশনগুলি

8

সিজেম, 37 বাইট

0q{"!><@"#"~ 2/ 2* GmdG*+ "S/=~255&}/

সিজেএম ইন্টারপ্রেটারে এটি অনলাইনে চেষ্টা করুন ।

কিভাবে এটা কাজ করে

0                   e# Push 0 (accumulator).
q                   e# Read from STDIN.
{                   e# For each character in the input:
  "!><@"#           e#   Find its index in "!><@" (-1 if not found).
  "~ 2/ 2* GmdG*+ " e#   Push that string.
  S/                e#   Split at spaces to push ["~" "2/" "2*" "GmdG*+" ""].
                    e#     "~"      : signed 64-bit bitwise NOT
                    e#     "2/"     : divide by 2
                    e#     "2*"     : multiply by 2
                    e#     "GmdG*+" : (x) -> (x/16) (x%16) -> (16(x%16) + (x/16))
                    e#     ""       : NOOP
  =~                e#  Select the corresponding string and evaluate it.
  255&              e#  Zero all but the 8 least significant bits.
}/                  e#

— ডেনিস
সূত্র

8

জাভা (8), 514 483 411 366 359 239 224 229 198 194 187 186 184 182 181 180 177 টি অক্ষর

বাহ, এটি অনেকটা গল্ফ হয়েছে! যারা আমাকে পরামর্শ দিয়েছেন তাদের প্রত্যেককে ধন্যবাদ! আমি এটির প্রশংসা করি!

interface T{static void main(String[]g)throws Exception{int i,a=0;while((i=System.in.read())!=10)a=(i==33?255-a:i==62?a/2:i==60?a*2:i==64?a>>4|a<<4:a)%256;System.out.print(a);}}

লম্বা Integer.???পদ্ধতির বিপরীতে বিটওয়াইজ অপারেশন সহ নীবলের অদলবদলকে অনুকূল করে গল্ফড 31 (!) বাইটস

গল্ফড 72 (!!!!) চরগুলি নিবলগুলি অদলবদল করার জন্য তৈরি অপ্রয়োজনীয় স্ট্রিং সরিয়ে দিয়ে। আগের চেয়ে অনেক ভাল !?

গল্ফযুক্ত 45 (!!) চরগুলি সরাসরি ব্যবহার থেকে সরিয়ে java.util.Scannerএবং পড়ার মাধ্যমে System.in। নোট করুন যে এখন ল্যাম্বডা এক্সপ্রেশনটি চলে গেছে, জাভা 8 এর আর প্রয়োজন নেই! নিছক জাভা 1 করত!

ক্লাস করে 7 টি চর গল্ফ করেছেন (default) ( publicকীওয়ার্ড সরানো হয়েছে ), @ বার্কসকে ধন্যবাদ

গল্ফড 120 (!!!!!!!) চরগুলিতে বিটকে উল্টে বিস্তৃত সমস্ত লম্বা Integerশ্রেণির ক্রিয়াকলাপ ঘুরিয়ে255 - a । এখন তা অনেক খাটো!

গল্ফড 15 (!) চরগুলি শিফটকে গুণ এবং বিভাগে রূপান্তর করে, বিবৃতি থেকে ব্রেসগুলি সরিয়ে, এবং এর aমধ্যে স্থানীয় করে তোলেmain পদ্ধতিটির ।

অবহেলিত 9 = (বাম দিকের শিফটটি বাম পাশের বাইটটিকে ত্যাগ না করার কারণে সমস্যাগুলি রয়েছে Therefore তাই, এখন আমি এটি করি mod (256)The ডান শিফটটি ফলাফলের ফলে আগের চেয়ে এক নম্বরকে আরও ছোট করে তুলবে, তাই modডান শিফটে ব্যবহার করার দরকার নেই । আমার স্তন্যপান-অদলবদলটি শেষ 4 টি বিট এবং দ্বিতীয়-শেষ স্তন্যপান এবং অদলবদল করবেand (&) অন্যান্য সমস্ত বিট কেটে ফেলবে My আসল সংখ্যা 256 এর চেয়ে কম হলে আমার বিপরীত প্রোগ্রামে কোনও সমস্যা হয় না problems

প্রচলিত বিবৃতিতে প্রচুর বিবৃতিতে রূপান্তর করে এবং অক্ষরগুলিকে ছোট করে ছোট করে ইনটগুলিতে রূপান্তরিত করে @ জিওবিটসকে গল্ফড ৩১ 35 টি চরিত্র ধন্যবাদ switchজানায়।

অপ্রয়োজনীয় সরিয়ে 7 অক্ষর Golfed &240(মৃদু কামড় swap 'র মধ্যে (a&240)>>4থেকে a>>4এবং রূপান্তর (a&15)<<4করার a<<4&240। শেষ পরিবর্তন শুধুমাত্র একটি অক্ষর যদিও golfed।

অপ্রয়োজনীয় সরিয়ে 1 গৃহস্থালির কাজ Golfed =মধ্যে a /= 2, কারণ a = a /= 2সমতূল্য a = a / 2।

বাঁক 2 অক্ষর Golfed printlnকরতে print।

আপতিক সরিয়ে 2 অক্ষর Golfed a=মধ্যে a=255-a( a=a=255-aসমতূল্য a=255-a)

গল্ফড 1 চর পরিণত a<<4&240করে a%16<<4।

গার্ফড 1 চর ত্রৈমাসিক স্টেটমেন্টের বাইরের সাথে বন্ধনী যুক্ত করে এবং করে %256। এইভাবে, %16স্তন্যপান অদলবদলের বাম-শিফ্ট অংশে অপ্রয়োজনীয়। বন্ধনীগুলিতে 2 টি অক্ষর যুক্ত হয় এবং %163 টি অক্ষর সংরক্ষণ হয়।

পরিবর্তন করে 3 টি অক্ষর Golfed classকরতে interfaceএবং সরিয়েছে publicজাভা 8 এর স্ট্যাটিক ইন্টারফেস পদ্ধতি বৈশিষ্ট্য ব্যবহার করে। @ দি নাম্বারওনকে ধন্যবাদ (কোনও মন্তব্য নেই, তবে "জাভাতে গল্ফ করার টিপস" - এ তার উত্তর খুঁজে নিন

— HyperNeutrino
সূত্র

আমি মনে করি না ক্লাসটি পাবলিক হতে হবে। এছাড়াও, আমি মনে করি আপনি যদি ইন্টের পরিবর্তে একটি পূর্ণসংখ্যা তৈরি করেন তবে আপনি পূর্ণসংখ্যা.পারসেন্ট, ইন্টিজার.টো স্ট্রিং ইত্যাদির পরিবর্তে a.parseInt, a.toString, ইত্যাদি করতে পারেন

— চিহ্নগুলি

প্রথম পরামর্শের জন্য ধন্যবাদ; আমি Integerযদিও সব শ্রেণি পদ্ধতি মুছে ফেলছি ।

— হাইপারনিউটারিনো

বাইট বাঁচানোর জন্য আপনি! = 10 এর পরিবর্তে ((i = System.in.read ())> 10) করতে পারেন?

— বেমমার্স

ভাল ধারণা, তবে তারপরে 10 এর নীচে যে কোনও কিছু করার ফলে প্রোগ্রামটি শেষ হয়ে যাবে এবং আমি অন্য চরিত্রগুলিকে উপেক্ষা করার কথা বলব, পৃথিবীর সমাপ্তি তৈরি করব না (বা কমপক্ষে আমার প্রোগ্রাম :)) আমি এটিকে বিবেচনা করব; সম্ভবত 10 এর নীচে কোনও বৈধ ascii অক্ষর নেই

— হাইপারনিউটারিনো

4

এটা প্রায় ব্যবহার করতে না করাটা switchযখন golfing। case/ breakশুধু অত্যন্ত দীর্ঘ। পুরো জিনিসটিকে তিন্নি করে আপনার একগুচ্ছ বাঁচাতে সক্ষম হওয়া উচিত; কিছু এরকমa=i=='!'?255-a:i==62?a/2:i=='<'?a*2%256:i=='@'?(a&240)>>4|(a&15)<<4:a;

— Geobits

7

মরিচা, 121 115 বাইট

fn r(s:&str)->u8{let mut n=0u8;for t in s.chars(){match t{'!'=>n=!n,'>'=>n/=2,'<'=>n<<=1,'@'=>n=n>>4|n<<4,_=>()}}n}

নমুনা রান:

fn main() {
    println!("{}", r("!"));    //=> 255
    println!("{}", r("!>>"));  //=> 63
    println!("{}", r("!<@"));  //=> 239
}

Ungolfed:

fn run_ungolfed(s: &str) -> u8 {
    let mut n = 0u8;
    for t in s.chars() {
        match t {
            '!' => n = !n,
            '>' => n >>= 1,
            '<' => n <<= 1,
            '@' => n = (n >> 4) | (n & 15) << 4,
            _ => ()
        }
    }
    n
}

মরিচা জন্য আশ্চর্যজনকভাবে সংক্ষিপ্ত। আমি আজ আরও বেশি প্রাধান্য পেয়েছি তার চেয়ে সত্যই আর আকর্ষণীয় আর কিছু নেই knew (a>>b)|cকে জানত সেই একই a>>b|c?

পরিবর্তন করে একটি বাইট কামিয়ে n>>=1করতে n/=2; তবে গুণের সাথে একই কাজটি করা যায় না, কারণ পাটিগণিত ওভারফ্লোটি মরিচায় একটি আতঙ্ক (অর্থাত্ ক্রাশ)।

— ডোরকনব
সূত্র

2

যখন আপনি নিজেকে সন্তুষ্ট যে প্রাধান্য জিনিস জ্ঞান করে তোলে >>হয় সাজানোর বিভাজন মত ও |নয় সাজানোর উপরন্তু মত।

— লিন

6

এইচপি 41 সি / সিভি / সিএক্স (? বাইটস, 42 ধাপ)

খাঁটি গিগলসের জন্য, এখানে এটি এইচপি 41 সি / সিভি / সিএক্স ক্যালকুলেটারের জন্য। (এটি হয় এক্সটেন্ডেড ফাংশন মডিউল বা এটিস ফাংশনের জন্য একটি 41 সিএক্স প্রয়োজন।) দুর্ভাগ্যক্রমে ক্যালকুলেটর প্রোগ্রামের আকারগুলিকে বাইটে প্রতিবেদন করে না।

আপনার প্রোগ্রামটি আলফা রেজিস্টারে রাখুন, যা কিছুটা জটিল, কারণ প্রবেশের কোনও উপায় নেই! বা @ সরাসরি কীবোর্ড থেকে (এএসসিআইআই কোডগুলি যুক্ত করতে যথাক্রমে 33 এবং 64 এর সাথে এক্সটিওএ ব্যবহার করুন)।

08 এবং 10 পদক্ষেপগুলি অবৈধ অপকডগুলি উপেক্ষা করার জন্য অনুমতি দেয়; 2 টি পদক্ষেপ বাঁচাতে এগুলি সরিয়ে ফেলুন, তবে প্রোগ্রামটি অবৈধ ইনপুটটিতে ক্রাশ হবে।

01 LBL"BB
02 0
03 LBL A
04 ATOX
05 X=0?
06 GTO E
07 X<>Y
08 SF 25
09 XEQ IND Y
10 CF 25
11 GTO A
12 LBL 33
13 255
14 X<>Y
15 -
16 RTN
17 LBL 60
18 2
19 *
20 256
21 MOD
22 RTN
23 LBL 62
24 2
25 /
26 INT
27 RTN
28 LBL 64
29 RCL X
30 16
31 /
32 INT
33 X<>Y
34 16
35 *
36 256
37 MOD
38 +
39 RTN
40 LBL E
41 RDN
42 RTN

— DB2
সূত্র

6

পাইথন 2, 79 বাইট

আমি বুঝতে পেরেছিলাম যে পাইথনে আমি এর আগে খুব একই রকম কিছু করেছি । এটি আমার রুবির উত্তরের একটি বন্দর মাত্র , তবে ঘটনাক্রমে এটি এখনকার সংক্ষিপ্ততম পাইথন উত্তর: ডি

a=0
for i in raw_input():a=[~a,a/2,a*2,a*16+a/16,a]["!><@".find(i)]&255
print a

রুবি সংস্করণ থেকে পার্থক্য হ'ল ইনপুটটি পুনরাবৃত্তি করার সময় এইটি অবৈধ নির্দেশনা উপেক্ষা করে না। পরিবর্তে আমি এই সত্যটির সদ্ব্যবহার করছি যে কোনও ম্যাচ না হওয়ার -1পরিবর্তে পাইথন ফিরতে ঝোঁক nil- বর্তমান মানটির aফলাফল অ্যারের পিছনে সংযোজন করা হয়, যাতে সমস্ত অবৈধ নির্দেশাবলীর মান একই, অপরিবর্তিত মানকে দেওয়া হয়।

— daniero
সূত্র

4

পাইথন 3, 124 94 93 বাইট

a=0
for i in input():
 if i in"!><@":a=(i=='!')*(255-a)+(i==">")*a//2+(i=="<")*(a+a)%256+(i=="@")*(16*(a%16)+a//16)
print(a)

"!" হয় 255 থেকে বিয়োগ হিসাবে একই
"<" 2. কিন্তু 8 বিট রেজিস্টার উপায়ে গুন হিসাবে একই mod 256.
">" 2. দ্বারা পূর্ণসংখ্যা বিভাজন হিসাবে একই
"@" মানে গত 4 বিট নাড়াচাড়া ( a%16) 4 টি বিট দ্বারা ( *16) এবং প্রথম চারটি বিট যুক্ত করুন ( a/16)।

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

a=0
for i in input():a={"!":255-a,"<":a<<1&255,">":a//2,"@":(a%16)<<4+a>>4}.get(i,a)
print(a)

ধন্যবাদ, বেটা ক্ষয়

— Rohcana
সূত্র

আপনি কোন অপারেশনই করেন না কেন, আপনাকে মোড 256ঠিক কমাতে হবে ? সুতরাং কেন যে কি শেষে না: a={"!":255-a,"<":a*2,">":a//2,"@":(a%16)<<4+a>>4}.get(i,a)%256। এটি অবিলম্বে আপনাকে একটি বাইট বাঁচায় (কারণ আপনি a*2পরিবর্তে এটি করবেন a<<1) ... তবে @ ড্যানিরোর উত্তরটিও দেখায় যে আপনি যদি এইভাবে এটি করেন তবে (a%16)<<4কেবল সংক্ষিপ্ত করা যেতে পারে a<<4, কারণ আপনি সংখ্যাবৃদ্ধির পরে 16 বা ততোধিক বড় কোনও বিলোপ হবে will এটি 16 দ্বারা এবং 256 মোড এটি হ্রাস করুন N এছাড়াও, আপনি এখন ... 255-aদ্বারা -1-aবা আরও ভাল দ্বারা প্রতিস্থাপন করতে পারেন ~a। সামগ্রিকভাবে, এই পরামর্শগুলি আপনাকে 9 বাইট সংরক্ষণ করতে হবে।

— mathmandan

3

হাস্কেল, 89 বাইট

a#'!'=255-a
a#'>'=div a 2
a#'<'=mod(a*2)256
a#'@'=mod(a*16)256+div a 16
a#_=a
f=foldl(#)0

ব্যবহারের উদাহরণ: f "!>>"->63

— nimi
সূত্র

3

মরিচা, 111 বাইট

@ ডুরকনব এর উত্তর সম্পর্কে আরও মন্তব্য, তবে আমি খালি একটি অ্যাকাউন্ট তৈরি করায় মন্তব্যের জন্য আমার কাছে কোনও প্রতিবেদন নেই।

নিম্নলিখিতগুলির সাথে একটি তার মরিচ সমাধানটি 10 বাইট শেভ করতে পারে:

fn r(s:&str)->u8{let mut n=0u8;for t in s.chars(){n=match t{'!'=>!n,'>'=>n>>1,'<'=>n<<1,'@'=>n>>4|n<<4,_=>n}}n}

— user4867444
সূত্র

আমি ভেবেছিলাম যে আমরা ভাঁজ ( ডক্টরস্টআং.আল.এগ্র.আর.এস.ডি.ডি.সিটার / ট্রায়িট.আইট্রেটার.ইচটিএমএল # মেমোথড.ফোল্ড ) ব্যবহার করে আরও সংক্ষিপ্ত হয়ে উঠতে পারি তবে আশ্চর্যরকমভাবে এটি আরও দীর্ঘতর হয়ে যায়।

— ব্যবহারকারী 4867444

3

পাইথন 3, 127 বাইট

সম্পাদনা: সংক্ষিপ্তকরণ, ধন্যবাদ @ জাকুবে

সম্পাদনা 2: ঠিক আছে, ধন্যবাদ @ আনচোর

a=0
for i in input():a=(a^255if i=="!"else a>>1if i==">"else a<<1if i=="<"else(a&15)<<4|(a&240)>>4if i=="@"else a)&255
print(a)

— uno20001
সূত্র

উইন্ডোজগুলির নতুন লাইন কারণ এটি হতে পারে। এটি প্লাস টু বাইট। আমি পরের বার সেই বাইট কাউন্টারটি ব্যবহার করব। :-) ধন্যবাদ

— uno20001

মনে রাখবেন যে বাম স্থানান্তর করার সময় এটি বামদিকের বিটটি ফেলে দেয় না, তাই !<এটি হওয়ার 510সময় দেয়254

— রোহকানা

আমি এখন আশা করি। আমার ভুলের জন্য দুঃখিত, এটি আমার প্রথম "গল্ফ" চ্যালেঞ্জ।

— uno20001

3

সিলোন, 297 290

shared void y(){value t=process.readLine()else"";variable Byte a=0.byte;for(c in t){switch(c)case('!'){a=a.not;}case('>'){a=a.rightLogicalShift(1);}case('<'){a=a.leftLogicalShift(1);}case('@'){a=a.and(#f0.byte).rightLogicalShift(4).xor(a.and(#f.byte).leftLogicalShift(4));}else{}}print(a);}

বিন্যাসকৃত:

shared void y() {
    value t = process.readLine() else "";
    variable Byte a = 0.byte;
    for (c in t) { switch (c)
        case ('!') { a = a.not; }
        case ('>') { a = a.rightLogicalShift(1); }
        case ('<') { a = a.leftLogicalShift(1); }
        case ('@') { a = a.and(#f0.byte).rightLogicalShift(4).xor(a.and(#f.byte).leftLogicalShift(4)); }
        else {} }
    print(a);
}

#fএবং #f0নিবলগুলির জন্য হেক্সাডেসিমাল সংখ্যা, .byteএকটি পূর্ণসংখ্যাকে বাইটে রূপান্তর করে। আমি ভাগ্যবান যে বাইটের .stringগুণাবলী ইতিমধ্যে একটি বাইটের স্বাক্ষরযুক্ত প্রতিনিধিত্ব ব্যবহার করে uses সিলোন হ'ল ফল-থ্রো ছাড়াই একটি স্যুইচ স্টেটমেন্ট বৈশিষ্ট্যযুক্ত এবং স্ট্রিং অক্ষরের একটি তালিকা যা পুনরাবৃত্তি করা যেতে পারে।

আমিও এলিয়াসিং আমদানি ব্যবহার করে সেই দীর্ঘ শিফট পদ্ধতির নামগুলি কেটে ফেলার চেষ্টা করেছি, তবে এটি আসলে 7 বাইট দীর্ঘতর হয়:

import ceylon.language{Byte{r=rightLogicalShift,l=leftLogicalShift}}shared void x(){value t=process.readLine()else"";variable Byte a=0.byte;for(c in t){switch(c)case('!'){a=a.not;}case('>'){a=a.r(1);}case('<'){a=a.l(1);}case('@'){a=a.and(#f0.byte).r(4).xor(a.and(#f.byte).l(4));}else{}}print(a);}

বিন্যাসকৃত:

import ceylon.language {
    Byte {
        r=rightLogicalShift,
        l=leftLogicalShift
    }
}
shared void x() {
    value t = process.readLine() else "";
    variable Byte a = 0.byte;
    for (c in t) {
        switch (c)
        case ('!') { a = a.not; }
        case ('>') { a = a.r(1); }
        case ('<') { a = a.l(1); }
        case ('@') { a = a.and(#f0.byte).r(4).xor(a.and(#f.byte).l(4)); }
        else {}
    }
    print(a);
}

আমাদের যদি আরও কয়েকটি ঘন ঘন এই পদ্ধতিগুলির প্রয়োজন হয় তবে এটি কার্যকর হতে পারে।

— পাওলো ইবারম্যান
সূত্র

3

রুবি, 81 73 বাইট

এত সরল - কোন ইভাল! ইনপুটটিতে প্রতিটি বৈধ অক্ষরের জন্য, এটি প্রতিটি নির্দেশকে মূল্যায়ন করে এবং সূচকের $&(ইনপুটটিতে বর্তমান অক্ষর) মাধ্যমে উপযুক্ত নির্দেশটি সন্ধান করে ।

a=0
gets.scan(/[!><@]/){a=[~a,a/2,a*2,a*16+a/16]["!><@".index$&]&255}
p a

— daniero
সূত্র

1

এটা প্রতিভা। অন্য যে কোনও উপায়ে অনেক ছোট আমার দ্বারা 2 upvotes!

— edc65

আপনি কীভাবে দ্বিগুণ হতে পারেন ...?

— হাইপারনিউটারিনো

@ জেমস্মিথ তিনি সম্ভবত এটি এবং আমার অজগর উত্তরটি উল্লেখ করছেন :)

— ড্যানিরো

পছন্দ করুন

— হাইপারনিউট্রিনো

2

স্টাটা, 197 বাইট

di _r(a)
gl b=0
forv x=1/`=length("$a")'{
gl c=substr("$a",`x',1)
if"$c"=="!" gl b=255-$b
if"$c"==">" gl b=int($b/2)
if"$c"=="<" gl b=mod($b*2,256)
if"$c"=="@" gl b=mod($b,16)*16+int($b/16)
}
di $b

Ungolfed

display _request(a) //get the input via prompt and put in var a
global b=0 //initialise A to be 0
forv x=1/`=length("$a")'{ //for loop from 1 to last char in a
global c=substr("$a",`x',1) //get the char at index x in a
if "$c"=="!" global b=255-$b //invert is the same as 255-A
if "$c"==">" global b=int($b/2) //right shift is the same as A/2 (with integer division)
if "$c"=="<" global b=mod($b*2,256) //left shift is the same as A*2%256
if "$c"=="@" global b=mod($b,16)*16+int($b/16) //nibble swap is the same as A%16*16+A/16
}
display $b //display the result of A

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

— bmarks
সূত্র

কেন অনলাইন দোভাষী কাজ করেন না?

— ক্যালকুলেটরফলাইন

2

জাভাস্ক্রিপ্ট, 104

[].reduce.call(prompt(),function(a,i){return(i=='!'?~a:i=='>'?a/2:i=='<'?a*2:i=='@'?a>>4|a<<4:a)&255},0)

নেস্টেড টেরিনারি অপারেটরদের নির্দেশাবলীর মানচিত্র।

BITWISE এবং আমাদের নম্বর প্রকারটি একক বাইটে সীমাবদ্ধ করতে ব্যবহৃত হয়।

— অ্যান্ড্রু ভার্মি
সূত্র

2

জুলিয়া, 117 94 86 73 বাইট

p->(a=0x0;[a=c==33?~a:c==60?a<<1:c==62?a>>1:c!=64?a:a<<4|a>>4for c=p];1a)

এটি একটি বেনাম ফাংশন যা একটি স্ট্রিং গ্রহণ করে এবং পূর্ণসংখ্যা ফেরত দেয়। এটি কল করতে, এটি একটি ভেরিয়েবলের জন্য বরাদ্দ করুন।

Ungolfed:

function f(p)
    # Initialize the accumulator to 0 as an 8-bit unsigned integer
    a = 0x0

    # Loop over the characters in the input
    for c in p
        a = c == 33 ? ~ a :        # '!'
            c == 60 ? a << 1 :     # '<'
            c == 62 ? a >> 1 :     # '>'
            c != 64 ? a :          # no-op
            a << 4 | a >> 4        # '@'
    end

    # Convert the accumulator to a regular integer and return
    return Int(a)
end

স্পেন 3 টি এবং ডেনিসকে 13 ধন্যবাদ 8 বাইট সংরক্ষণ করা!

— অ্যালেক্স এ।
সূত্র

2

জাভাস্ক্রিপ্ট (ES6), 76 81

একচেটিয়া মান হিসাবে সঞ্চয়ের মানটি ফিরিয়ে আনছে

এটি @ ড্যানিরো দ্বারা চালিত উত্তম চৌকস উত্তরের একটি পোর্টিং (এতে খুব কম আপোভেট রয়েছে)

বোনাস: আপনি সঞ্চয়ের প্রাথমিক মানটি পাস করতে পারেন । যদি পাস না হয় তবে প্রারম্ভিক মানটি নির্দিষ্ট হিসাবে 0 হয়।

(p,a)=>(p.replace(/[!<>@]/g,i=>a=(i<'<'?~a:i<'>'?a*2:i<'@'?a/2:a*257/16)&255),a)

যে কোনও ইকামাস্ক্রিপ্ট 6 ব্রাউজারে নীচে স্নিপেট চালানোর পরীক্ষা করুন (আমি ফায়ারফক্সে পরীক্ষা করেছি)

f=(p,a)=>[...p].map(c=>a=255&[a,~a,a*2,a/2,a*257/16][1+'!<>@'.indexOf(c)])|a

// TEST
out=x=>O.innerHTML+=x+'\n'

function go(x) { out(x+' -> '+f(x)) }

go('!'),go('!>>'),go('!<@'),go('!nop!&6*!')

// LESS GOLFED
F=(p,a)=>// a as a parameter, if not passed its value starts as undefined, then becomes NaN, but the operators '&' and '~' treat it as 0
  [...p].map(c => // execute following function for each character p
    a = 255 & // any intermediate result is converted to numeric and truncate to a byte          
   // evaluate all possible results (then choose one bases on the current character)
   [a,   // NOP, if unexpected char 'a' remains the same
    ~a,  // tilde == binary not (will give a result wider than a byte)
    a*2, // < shift left is *2 (can give a result wider than a byte) 
    a/2, // > shift right is /2 (can give a non integer result)
    a *257 / 16  // move nibbles around (will give a result wider than a byte)
   ] // array of all results
   [1+'!<>@'.indexOf(c)] // find index to get the correct result
  ) // end map, returns an array in any case
    // eventually a single element array containg a
  | a // return accumulator

Test program:<input id=I><button onclick='go(I.value)'>go</button>
<pre id=O></pre>

স্নিপেট প্রসারিত করুন

— edc65
সূত্র

1

স্ফটিক, 139 বাইট

def f x
b=0_u8
x.chars.each do|c|
b=case c
when'!'
~b
when'>'
b>>1
when'<'
b<<1
when'@'
b<<4|b>>4
else raise ""
end
end
puts b
end

— kirbyfan64sos
সূত্র

1

সি # 193

void Main(){byte a=0;foreach(var c in Console.ReadLine()){if(c=='!')a=(byte)~a;if(c=='>')a=(byte)(a>>1);if(c=='<')a=(byte)(a<<1);if(c=='@')a=(byte)(((a&240)>>4)|((a&15)<<4));}Console.Write(a);}

— স্টিফান শিনকেল
সূত্র

2

using System;অ্যাক্সেস করার জন্য Console.ReadLineএবং উপসর্গ Console.Writeছাড়া আপনার কি এমন কিছু দরকার নেই System.?

— অ্যালেক্স এ।

এছাড়াও এটি আমার কাছে মনে হয় যে byteপ্রতিটি অপারেশনের জন্য আপনাকে কাস্ট করতে হবে না তবে আমি ভুল হতে পারি।

— অ্যালেক্স এ।

1

লুয়া, 344 চর

a=string.rep("0",8)
t=io.read()
f={["!"]=function()local s="";for j=1,8 do s=s..(a:sub(j,j)=="0"and"1"or"0") end;return s end,[">"]=function() return "0"..a:sub(1,7) end,["<"]=function()return a:sub(2,8).."0"end,["@"]=function()return a:sub(5,8)..a:sub(1,4)end}
for i=1,#t do a=(f[t:sub(i,i)]or function()return a end)()end
print(tonumber(a,2))

@ বেটা ডেকের স্ট্রিং সংগ্রহকারী ব্যবহারের মাধ্যমে অনুপ্রাণিত হয়ে লুয়ার কোনও বাইট প্রকার নেই তা দেখে। কম ফাংশন ব্যবহার করে সম্ভবত আরও গল্ফ করা যেতে পারে।

— ডিলিয়া এরিকসন
সূত্র

1

আর, 194 বাইট

b<-readline();A<-rep(0,8);s<-strsplit(b,"")[[1]];for(r in s){if(r=="!")A<-(A+1)%%2;if(r==">")A<-c(0,A)[1:length(A)];if(r=="<")A<-c(A,0)[-1];if(r=="@")A<-c(A[5:8],A[1:4])};print(sum(A*(2^(7:0))))

ungolfed

b <- readline()
A <- rep(0, 8) 
s <- strsplit(b, "")[[1]]
for (r in s) {
    if (r == "!")
        A <- (A + 1) %% 2
    if (r == ">")
        A <- c(0, A)[1:length(A)]
    if (r == "<")
        A <- c(A, 0)[-1]
    if (r == "@")
        A <- c(A[5:8], A[1:4])
}
print(sum(A*(2^(7:0))))

— mawir
সূত্র

এখানে সমস্ত <-দ্বারা প্রতিস্থাপন করা যেতে পারে =, সুতরাং 7 বাইট দ্বারা কোড হ্রাস। অতিরিক্ত হিসাবে আপনি ifswitchA=switch(r,"!"=(A+1)%%2, ...)

— বিবরণগুলির

ফলাফল

b=readline();A=rep(0,8);s=strsplit(b,"")[[1]];for(r in s)A=switch(r,"!"=(A+1)%%2,">"=c(0,A)[1:length(A)],"<"=c(A,0)[-1],"@"=c(A[5:8],A[1:4]),A);print(sum(A*(2^(7:0))))

167 বাইট।

— প্লানাপাস

1

আরপিএল, 170.5 বাইট

ইনপুটটি স্তর 1 এর স্ট্রিং হিসাবে প্রবেশ করা উচিত।

\<< DEC 8 STWS \-> S 
    \<< #0d 1 S SIZE 
        FOR I "!><@" S I DUP SUB POS 1 + { \<< \>> NOT SR SL \<< DUP #16d / SWAP #16d * + \>> } SWAP GET EVAL NEXT \>> 
\>>

— জেসন
সূত্র

1

কে, 57 বাইট

এটি একটি শুরু:

0{y+2*x}/(8#0){((~:;{-1_0,x};{1_ x,0};4!;{x})"!><@"?y)x}/

কোনা ব্যবহার করে পরীক্ষিত:

  f:0{y+2*x}/(8#0){((~:;{-1_0,x};{1_ x,0};4!;{x})"!><@"?y)x}/
...
  f'("!";"!>>";"!<@";"!nop!&6*!")
255 63 239 255

আমি K5 ভালো কাজ করতে সক্ষম হতে পারে, কিন্তু এটা উদাহরণস্বরূপ tradeoffs- এক জটিল সিরিজ, দশমিক বাইনারি রূপান্তর হিসাবে সহজ হিসাবে 2/, কিন্তু আচরণ ?কঠিন নির্দেশ লুকআপ জন্য একটি ডিফল্ট ক্ষেত্রে হ্যান্ডেল করে তোলে।

— JohnE
সূত্র

1

পিএইচপি, 189 বাইট

<? $c='00000000';foreach(str_split($argv[1])as$a){$a=='!'&&$c=strtr($c,'01','10');$a=='<'&&$c=substr($c.'0',1);$a=='>'&&$c=substr('0'.$c,0,8);$a=='@'&&$c=substr($c.$c,4,8);}echo bindec($c);

এটি এমন নয় যে এটি অনেক উত্তরকে পরাজিত করবে, এটি কেবল অনুশীলনের জন্য

— Einacio
সূত্র

1

এইচপিপিএল , 302 294 বাইট

#pragma mode(separator(.,;)integer(d8))EXPORT b()BEGIN print();local p,j,a;a:=#0d;INPUT({{p,[2]}});for j from 1 to dim(p)do c:=p(j);case if c==33 then a:=BITNOT(a)end if c==62 then a:=BITSR(a,1)end if c==60 then a:=BITSL(a,1)end if c==64 then a:=BITSL(a,4)+BITSR(a,4)end end;end;print(a*1);END;

Ungolfed:

// make sure integers are unsigned 8 bit decimal numbers
#pragma mode( separator(.,;) integer(d8) ) 
EXPORT b()
BEGIN
  print();
  local p,j,a;
  a:=#0d;                         // set a to integer value 0
  INPUT({{p,[2]}});               // open input dialog treating input as string ( type [2])
  for j from 1 to dim(p) do
    c:=p(j);
    case
      if c==33 then a:=BITNOT(a) end             // !
      if c==62 then a:=BITSR(a,1) end            // >
      if c==60 then a:=BITSL(a,1) end            // <
      if c==64 then a:=BITSL(a,4)+BITSR(a,4) end // @
    end;
  end;
  print(a*1); // converts to proper output by promoting to non integer format
              // print(a) would result in
              // #239:8d for 239 if the default bit size is not set to 8 bits decimal
              // indicating an 8 bit unsigned decimal integer, or
              // #239d if the default bit size is already set to 8 bits decimal

END;

এই উত্তরটি নিশ্চিত করে যে এইচপি প্রাইম স্বাক্ষরযুক্ত 8 বিট পূর্ণসংখ্যার ব্যবহার করে এমনকি মোডটি যেমন ব্যবহারকারী দ্বারা 64 বিট হিসাবে সেট করা থাকে। স্বাক্ষরযুক্ত 8 বিট দশমিক পূর্ণসংখ্যার ব্যবহারের জন্য যদি ক্যালকুলেটরটি ম্যানুয়ালি সেট আপ করা হয়, তবে pragmaকমান্ডটি বাদ দেওয়া যেতে পারে। যদি আউটপুটটির কঠোরভাবে ফর্ম্যাটটি অনুসরণ করার প্রয়োজন না হয় তবে শেষেটি a*1সহজভাবে হতে পারে a। ফলাফলটিকে 1 দ্বারা গুণিত করা কেবল আউটপুটটিকে পূর্ণসংখ্যার মানগুলির জন্য অভ্যন্তরীণ আউটপুট অনুসরণ করে না তা নিশ্চিত করে। printফলাফল প্রিন্ট করার আগে টার্মিনালটি সাফ করার দরকার না হলে লাইন 4- এ থাকা কমান্ডটিও বাদ দেওয়া যেতে পারে। যদি স্ট্রিং আর্গুমেন্ট হিসাবে প্রোগ্রামটি পাস করার অনুমতি দেওয়া হয়, তবে INPUTকমান্ডটিও বাদ দেওয়া যেতে পারে।

প্রগমা আর্গুমেন্ট ছাড়াই এটি ইনপুট এবং সঠিক আউটপুট সহ সংক্ষিপ্ততম সংস্করণ (যদি ক্যালকুলেটরটি ইউিনট 8 এ ডিফল্টরূপে সেট করা থাকে:

243 বাইট:

EXPORT b()BEGIN local p,j,a;a:=#0d;INPUT({{p,[2]}});for j from 1 to dim(p)do c:=p(j);case if c=33 then a:=BITNOT(a)end if c=62 then a:=BITSR(a,1)end if c=60 then a:=BITSL(a,1)end if c=64 then a:=BITSL(a,4)+BITSR(a,4)end end;end;print(a*1);END;

— এমএল
সূত্র

1

পার্ল 6, 96 89 বাইট

{my $a=0;$a=(+^*,*+<1,*+>1,{$_+<4+$_+>4},{$_})["!<>@".index($_)//4]($a)%256 for .comb;$a}

পুরানো সমাধান:

{my $a=0;$a=(255-*,*+<1+&255,*+>1,{$_+&15+<4+$_+>4},{$_})["!<>@".index($_)//4]($a)for .comb;$a}

— bb94
সূত্র

1

সি #, 119 বাইট

i=>{var a=0;foreach(var c in i){if(c=='!')a=~a;if(c=='>')a>>=1;if(c=='<')a<<=1;if(c=='@')a=a<<4|a>>4;a&=255;}return a;}

অন্যান্য সংস্করণগুলি আমি চেষ্টা করেছি, তবে আরও বাইট দরকার:

Func<string,int>C=i=>{var a=0;foreach(var c in i){switch(c){case'!':a=~a;break;case'<':a<<=1;break;case'>':a>>=1;break;case'@':a=a<<4|a>>4;break;}a&=255;}return a;};

// This is, despite having the worst score, my personal favourite :D
Func<string,int>D=i=>{var f=new Dictionary<char,Func<int,int>>{{'!',q=>~q},{'<',q=>q<<1},{'>',q=>q>>1},{'@',q=>q<<4|q>>4}};var a=0;foreach(var c in i)if(f.ContainsKey(c))a=f[c](a)&255;return a;};

— স্টিফান
সূত্র

1

পাইথন 2.7.3, 104 বাইট

স্ট্রিংয়ে কোডগুলি মূল্যায়নের জন্য দেখতে বেশ নোংরা লাগছে, তবে কাজ করে: ডি

a=0
for c in raw_input():a=eval({'!':'~a','<':'a<<1','>':'a>>1','@':'a<<4|a>>4'}.get(c,'a'))&255
print a

এখানে আউটপুট (এবং ইনপুট আসলে ..)

এবং হ্যাঁ, এটি সত্যিই একটি রাস্পবেরিপিতে চলছে:

— স্টিফান
সূত্র

বিটস এবং বাইটস সহ প্রোগ্রামিং

!: বিপর্যয়

>: শিফট ডানদিকে

<: শিফট বাম

@: নেব্বলগুলি অদলবদল করুন

বিধি

পাইথ, 36 35 বাইট

সি, 96

পাইথন 3, 133 বাইট

আই / ও উদাহরণ:

জাভাস্ক্রিপ্ট (ES6), 80 91 90 বাইট

সিজেম, 37 বাইট

কিভাবে এটা কাজ করে

জাভা (8), 514 483 411 366 359 239 224 229 198 194 187 186 184 182 181 180 177 টি অক্ষর

মরিচা, 121 115 বাইট

এইচপি 41 সি / সিভি / সিএক্স (? বাইটস, 42 ধাপ)

পাইথন 2, 79 বাইট

পাইথন 3, 124 94 93 বাইট

হাস্কেল, 89 বাইট

মরিচা, 111 বাইট

পাইথন 3, 127 বাইট

সিলোন, 297 290

রুবি, 81 73 বাইট

স্টাটা, 197 বাইট

জাভাস্ক্রিপ্ট, 104

জুলিয়া, 117 94 86 73 বাইট

জাভাস্ক্রিপ্ট (ES6), 76 81

স্ফটিক, 139 বাইট

লুয়া, 344 চর

আর, 194 বাইট

আরপিএল, 170.5 বাইট

কে, 57 বাইট

পিএইচপি, 189 বাইট

এইচপিপিএল , 302 294 বাইট

পার্ল 6, 96 89 বাইট

সি #, 119 বাইট

পাইথন 2.7.3, 104 বাইট

`!`: বিপর্যয়

`>`: শিফট ডানদিকে

`<`: শিফট বাম

`@`: নেব্বলগুলি অদলবদল করুন