পুনরাবৃত্তি বাইট কাউন্টার


19

আপনার কাজ হ'ল বাইট গণনা এল এর একটি খালি নয় এমন প্রোগ্রাম / ফাংশন লিখুন যা এম বারবার পুনরাবৃত্তি করার পরে প্রদত্ত ধনাত্মক পূর্ণসংখ্যা N L × M এর সমান কিনা তা পরীক্ষা করে ।

তাত্ত্বিকভাবে আপনাকে পুনরাবৃত্তির একটি স্বেচ্ছাসেবী সংখ্যার ( এম এর একটি স্বেচ্ছাকৃত ধনাত্মক পূর্ণসংখ্যার মান ) সমর্থন করা উচিত, তবে এটি ঠিক আছে যদি ভাষার সীমাবদ্ধতার কারণে এটি একটি নির্দিষ্ট দোরগোড়ায় কাজ করতে না পারে। আপনার প্রোগ্রামের উত্স কোড পড়া বা এটি সম্পর্কে তথ্য অ্যাক্সেস করা কঠোরভাবে নিষিদ্ধ

আউটপুট সরবরাহের জন্য, আপনার কোনও একটি রাজ্যের (একটি সত্যবাদী বা মিথ্যা) জন্য একটি সামঞ্জস্যপূর্ণ মান নির্বাচন করা উচিত এবং অন্য কোনও রাজ্যের ( আলোচনা নয়) সম্ভাব্য আউটপুট (অপরিহার্যভাবে সামঞ্জস্যপূর্ণ নয়) ব্যবহার করা উচিত ।

আপনার উত্তরগুলি আপনার প্রাথমিক প্রোগ্রামের দৈর্ঘ্য এল (বাইটগুলিতে) দ্বারা স্কোর করা হবে , কম বাইট ভাল হওয়ার সাথে।

উদাহরণ

ধরা যাক আপনার (প্রাথমিক) প্রোগ্রামটি ABCDE। তারপর:

  • ABCDE(1 পুনরাবৃত্তি) ইনপুট 5 এর সমান কিনা তা পরীক্ষা করা উচিত ।
  • ABCDEABCDE(2 পুনরাবৃত্তি) ইনপুট 10 এর সমান কিনা তা পরীক্ষা করা উচিত ।
  • ABCDEABCDEABCDE(3 পুনরাবৃত্তি) ইনপুট 15 সমান কিনা তা পরীক্ষা করা উচিত । ইত্যাদি ...

প্রাথমিক উত্স 5 বাইট দীর্ঘ হওয়ায় এই নমুনা কোডটির স্কোর 5 হবে ।


কেবল স্পষ্ট করে বলার জন্য: সূত্রের দৈর্ঘ্যের কোডটি সংক্ষিপ্ত হয়ে Lযাওয়ার পরে Mসময়গুলি ফিরে আসবে কিনা এর ইনপুটটি Nসমান কিনাL*M ?

উত্তর:


12

জেলি , 1 বাইট

আউটপুট একটি ম্যাচের জন্য 0 , অ-ম্যাচের জন্য শূন্য নয়।

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

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

এটি অত্যধিক উদার আউটপুট ফর্ম্যাটটির সুবিধা দেয়। এম বার পুনরাবৃত্তি করা সহজভাবে ইনপুট এম বার হ্রাস করে , সুতরাং ফলাফল শূন্য হবে এবং কেবল ইনপুটটি এলএম হলে , যেখানে এল = 1 থাকে


ওহ god শ্বর আমি এই আগমনটি দেখিনি ... ( ইনব 4 সকলেই এটিকে অন্য এসোলেংগুলিতে পোর্ট করে ... )
মিঃ এক্সকডার

আমার মনে 0-বাইট উত্তর ছিল, তবে, এঁ , কুইন । : পি
এরিক দি আউটগল্ফার

আমার প্রথম চিন্তা। 23 মিনিটের দ্বারা
মারধর

11

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

(-8+).id

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

অন্যান্য অনেক উত্তরের মতো এটি ইনপুট নম্বর থেকে বারবার কোডের দৈর্ঘ্য বিয়োগ করে সত্যবাদী এবং অ-0 এর জন্য প্রত্যাবর্তন করে।


আমার বয়স এখন এই চাওয়ার জন্য tinkering পাসে ...
totallyhuman

8

রেটিনা , 21 20 বাইট

\d+
*
^$
_
^_{20}

_

এটি অনলাইন চেষ্টা করুন! কোড উইন্ডোতে অংশটি পুনরাবৃত্তি করুন এটি কীভাবে গুণকে পরিচালনা করে।

0অন্য সব কিছুর জন্য সঠিক একাধিক এবং ধনাত্মক পূর্ণসংখ্যার জন্য দেয় ।

ব্যাখ্যা

প্রথমে একক প্রোগ্রামটি দেখুন:

\d+
*

এটি দশমিক সংখ্যাটিকে আনারিতে রূপান্তরিত করে ( _আনরি অঙ্ক হিসাবে ব্যবহার করে )।

^$
_

যদি স্ট্রিংটি খালি থাকে (যা এই মুহুর্তে ঘটতে পারে না, কারণ ইনপুটটি ইতিবাচক হওয়ার গ্যারান্টিযুক্ত), আমরা এটি একটি একক দিয়ে প্রতিস্থাপন করি _

^_{20}

এখন আমরা প্রথম 20 আন্ডারস্কোর থেকে মুক্তি পেয়েছি। যদি ইনপুটটি হয় 20, এটি একটি খালি স্ট্রিংয়ের ফলাফল।

_

এবং পরিশেষে আমরা ফলাফলটিতে আন্ডারস্কোরগুলির সংখ্যা গণনা করি, যা ইনপুট ছিল শূন্য 20


এখন যখন আমরা উত্স কোডটি পুনরাবৃত্তি করি তখন কী হয়। যেহেতু আমরা প্রোগ্রামগুলিতে যোগ দেওয়ার সময় একটি লাইনফিড সন্নিবেশ করি না, তাই প্রথম লাইনটি শেষ লাইনের শেষে চলে যাবে, দ্বিগুণ প্রোগ্রামের পরে আমরা এটি পাই:

\d+
*
^$
_
^_{20}

_\d+
*
^$
_
^_{20}

_

এখন আন্ডারস্কোরগুলি গণনা করার পরিবর্তে আমরা নিম্নলিখিত পর্যায়ে শেষ করব:

_\d+
*

এই পর্যায়টি কিছুই করে না, কারণ এই মুহুর্তে ওয়ার্কিং স্ট্রিংয়ে আরও কোনও সংখ্যা নেই, তাই রেজেক্সটি মেলতে পারে না।

^$
_

এখন এই পর্যায়ে প্রাসঙ্গিক হয়ে ওঠে। যদি ইনপুটটি 20 এর চেয়ে ছোট একাধিক হয় তবে উত্স কোডটির পূর্ববর্তী অনুলিপিটি দিয়ে স্ট্রিংটি খালি করা হয়েছে। সেক্ষেত্রে আমরা এটিকে একটি একক আন্ডারস্কোরতে পরিণত করি, যা আমরা জানি আমাদের প্রোগ্রামের মাধ্যমে আর কখনও খালি স্ট্রিংয়ে রূপান্তরিত করা যায় না। এই ভাবে আমরা নিশ্চিত শুধুমাত্র এম তম একাধিক গৃহীত (এবং সব আপ গুণিতক এম তম)।

^_{20}

আমরা প্রথম 20 আন্ডারস্কোরগুলি আরও একবার সরিয়ে ফেলি। সুতরাং উত্স কোডের এম পুনরাবৃত্তিগুলি সম্ভব হলে স্ট্রিং থেকে 20 এম আন্ডারস্কোরগুলি সরিয়ে ফেলবে ।

_

এবং যখন আমরা প্রোগ্রামটির শেষে পৌঁছে যাই, আমরা এখনও আন্ডারস্কোরগুলি গণনা করি যাতে বৈধ ইনপুটগুলি শূন্য দেয়।


6

x86 32-বিট মেশিন কোড খণ্ড, 1 বাইট

48                      dec    eax

EAX ইনপুট, EAX এ আউটপুট: 0 সত্য, মিথ্যা জন্য শূন্য নয়। (সত্যের জন্য জেডএফ পতাকা সেটটি ফেলে রাখে, মিথ্যাটির জন্য আনসেট রাখুন, যাতে আপনি পারেন je was_equal)। একটি "বোনাস" হিসাবে, আপনাকে মোড়ানো সম্পর্কে চিন্তা করতে হবে না; 32-বিট x86 কেবল 4GiB মেমরিকে সম্বোধন করতে পারে, তাই আপনি পুরোপুরি মোড়ানো এবং খুঁজে পেতে 1 == 2**32 + 1বা কিছু খুঁজে দেওয়ার জন্য এমকে যথেষ্ট বড় করতে পারবেন না ।

কলযোগ্য ফাংশন করতে, এম বার 0xC3 retপুনরাবৃত্তি করার পরে একটি নির্দেশ যুক্ত করুন 0x48। (মোট গণনাতে গণনা করা হয়নি, কারণ প্রতিযোগিতা করতে সক্ষম হওয়ার জন্য অনেক ভাষার কেবল ফাংশন বডি বা একটি অভিব্যক্তি পুনরাবৃত্তি করা প্রয়োজন)।

প্রোটোটাইপ সঙ্গে গনুহ C থেকে Calleable __attribute__((regparm(1))) int checkeqM(int eax); গনুহ সি এর regparmএক্স 86 ফাংশন বৈশিষ্ট্য , মত -mregparm, প্রথম পূর্ণসংখ্যা ARG পাস EAX ব্যবহার করে।

উদাহরণস্বরূপ, এই সম্পূর্ণ প্রোগ্রামটি 2 টি আরগস নেয় এবং জেআইটি এম এম নির্দেশের কপিগুলি + এ retএকটি বাফারে নিয়ে যায় এবং তারপরে এটিকে ফাংশন হিসাবে ডাকে। (এক্সিকিউটেবল গাদা প্রয়োজন; এর সাথে সংকলন gcc -O3 -m32 -z execstack)

/******* Test harness: JIT into a buffer and call it ******/
// compile with gcc -O3 -no-pie -fno-pie -m32 -z execstack
// or use mprotect or VirtualProtect instead of -z execstack
// or mmap(PROT_EXEC|PROT_READ|PROT_WRITE) instead of malloc

// declare a function pointer to a regparm=1 function
// The special calling convention applies to this function-pointer only
// So main() can still get its args properly, and call libc functions.
// unlike if you compile with -mregparm=1
typedef int __attribute__((regparm(1))) (*eax_arg_funcptr_t)(unsigned arg);

#include <stdlib.h>
#include <string.h>
#include <stdio.h>

int main(int argc, char *argv[])
{
    if (argc<3) return -1;
    unsigned N=strtoul(argv[1], NULL, 0), M = strtoul(argv[2], NULL, 0);

    char *execbuf = malloc(M+1);   // no error checking
    memset(execbuf, 0x48, M);     // times M  dec eax
    execbuf[M] = 0xC3;            // ret
    // Tell GCC we're about to run this data as code.  x86 has coherent I-cache,
    // but this also stops optimization from removing these as dead stores.
    __builtin___clear_cache (execbuf, execbuf+M+1);
     //   asm("" ::: "memory");  // compiler memory barrier works too.

    eax_arg_funcptr_t execfunc = (eax_arg_funcptr_t) execbuf;
    int res = execfunc(N);
    printf("%u == %u  =>  %d\n", N,M, res );
    return !!res;   // exit status only takes the low 8 bits of return value
}

ভার্চুয়াল মেমরিতে নন-পিআইই এক্সিকিউটেবলগুলি লোড হয়; একটি বৃহত্তর সংলগ্ন malloc করতে পারেন।

$ gcc -g -O3 -m32 -no-pie -fno-pie -fno-plt -z execstack coderepeat-i386.c
$ time ./a.out 2747483748 2747483748   # 2^31 + 600000100 is close to as big as we can allocate successfully
2747483748 == 2747483748  =>  0

real    0m1.590s     # on a 3.9GHz Skylake with DDR4-2666
user    0m0.831s
sys     0m0.755s

$ echo $?
0

 # perf stat output:
       670,816      page-faults               #    0.418 M/sec                  
 6,235,285,157      cycles                    #    3.885 GHz                    
 5,370,142,756      instructions              #    0.86  insn per cycle         

নোট করুন যে জিএনইউ সি অবজেক্ট মাপগুলি ptrdiff_t(স্বাক্ষরিত 32-বিট) এর চেয়ে বড় সমর্থন করে না , mallocএবং memsetএখনও কাজ করে, তাই এই প্রোগ্রামটি সফল হয়।

এআরএম থাম্ব মেশিন কোড টুকরা, 2 বাইট

 3802            subs    r0, #2

প্রথম আর্গ ইন r0এবং রিটার্ন ভ্যালু r0হ'ল স্ট্যান্ডার্ড এআরএম কলিং কনভেনশন। এটি পতাকা ( sপ্রত্যয়) সেট করে । মজার ব্যাপার; এর নন -ফ্ল্যাগ-সেটিং সংস্করণটি sub32-বিট প্রশস্ত নির্দেশিকা।

আপনাকে সংযুক্ত করার জন্য প্রয়োজনীয় রিটার্ন নির্দেশিকাটি হ'ল bx lr

AArch64 মেশিন কোড টুকরা, 4 বাইট

d1001000        sub     x0, x0, #0x4

-৪-বিট পূর্ণসংখ্যার জন্য কাজ করে। ইনপুট / আউটপুট ইন x0স্ট্যান্ডার্ড কলিং কনভেনশন অনুযায়ী। int64_t foo(uint64_t);

এআরচ ৪ এর একটি থাম্ব মোড নেই (এখনও), সুতরাং ১ টি নির্দেশনা আমরা সবচেয়ে ভাল।


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

4

ভি , 16 (বা 1) বাইট

বিরক্তিকর উত্তর:

<C-x>

এক বাইট

কম বিরক্তিকর উত্তর:

uÓ^$/0
16Ø^a$

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

Hexdump:

00000000: 75d3 5e24 2f30 0a31 3601 d85e 1261 240a  u.^$/0.16..^.a$.

আমি চ্যালেঞ্জটি আসার প্রায় 5 মিনিটের পরে এটি লিখেছিলাম। স্প্যাগেটি কোডের এই ভয়াবহ গাদাটি প্যাচ করতে আমার 30 মিনিট সময় লেগেছে যা আমি কোনও ভাষা বলে





2

ব্রেন-ফ্লাক , 24 বাইট

({}[(((()()()){}){}){}])

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

রিটার্নস 0জন্য সমান না করার জন্য অন্য সমান এবং কিছু।

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

({} #pop the top of the stack
  [(((()()()){}){}){}] #subtract 24
) #push the result.

এই কোড রান nসময়গুলি n * 24ইনপুট থেকে বিয়োগ করবে , কেবল ইনপুট = দিলে 0 দিবে n*24



2

টিআই-বেসিক (83 সিরিজ), 4 বাইট

:Ans-4

ইনপুট নেয় Ans: উদাহরণস্বরূপ, আপনি 17:prgmCODEGOLFকোনও ইনপুট দিয়ে এটি চালাতে টাইপ করতে পারেন 17। ইনপুটটি L × M এর সমান হলে Ansমান প্রিন্ট করে (এবং প্রত্যাবর্তন করে ) , এবং অন্যথায় একটি ননজারো মান।0

নোট করুন যে কোডটির :অংশ, তাই আপনি যদি প্রোগ্রাম এডিটারে এটি প্রবেশ করান, আপনার দেখতে হবে

PROGRAM:CODEGOLF
::Ans-4

যদি আপনি এটি একবার প্রবেশ করেন এবং

PROGRAM:CODEGOLF
::Ans-4:Ans-4:An
s-4

যদি আপনি এটি তিনবার প্রবেশ করেন।



1

বেফুঞ্জ -98 , 15 বাইট

]#<@.-&+
>fv
v+

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

দ্বিগুণ করে দেখুন!

সমান জন্য 0 এবং অসমের জন্য অন্য কিছু ব্যবহার করে।

ব্যাখ্যা:

এই কোডটি বহুবার পুনরাবৃত্তি করা এ জাতীয় কিছু দেখতে পাবেন:

]#<@.-&+
>fv
v+]#<@.-&+
>fv
v+]#<@.-&+
>fv
 .
 .
 .
v+]#<@.-&+
>fv
v+
  1. ]ডানদিকে মোড়. আইপি নীচে প্রেরণ করে।

  2. >পূর্ব দিকে সরান। সরাসরি আইপি প্রেরণ করে।

  3. f একটি 16 চাপুন।

  4. vদক্ষিণে সরান আইপি নীচে প্রেরণ করে। এটি যদি শেষ বার হয় তবে গোটো পদক্ষেপ 8।

  5. ]ডানদিকে মোড়. আইপি বামে প্রেরণ করে।

  6. +যোগ করুন। স্ট্যাকের শীর্ষে 16 টি যুক্ত করে।

  7. vদক্ষিণে সরান আইপি নীচে প্রেরণ করে। গোটো পদক্ষেপ 2।

  8. <পশ্চিমে সরান। আইপি বামে প্রেরণ করুন।

  9. #লাফালাফি করা। উপর তিড়িং লাফ ]এবং শেষ কাছাকাছি মোড়ানো।

  10. +যোগ করুন। স্ট্যাকের শীর্ষে 16 টি যুক্ত করে।

  11. &ইনপুট. ব্যবহারকারীর কাছ থেকে একটি নম্বর চাপুন।

  12. -বিয়োগ। আমরা যে পরিমানের উপর কাজ করছিলাম তার পার্থক্য এবং ইনপুট পান।

  13. .ছাপা. ফলাফল মুদ্রণ করুন।

  14. @ শেষ.


1

খাঁটি বাশ , 15

কমান্ড-লাইন প্যারামিটার হিসাবে ইনপুট দেওয়া হয়েছে। শেল প্রস্থান কোড হিসাবে আউটপুট - 1সত্য এবং 0মিথ্যা জন্য।

(((একটি + = 15) - $ 1))


1

কাঠকয়লা , 13 বাইট

PI⁼Iθ×¹³L⊞Oυω

এটি অনলাইন চেষ্টা করুন! আমি উত্স দ্বিগুণ আমার উত্তর উপর ভিত্তি করে , আপনি আউটপুট দ্বিগুণ! ব্যাখ্যা:

         ⊞Oυω   Push empty string to predefined empty list
        L       Take the length
     ×¹³        Multiply by 13
  ⁼Iθ           Compare to the input
 I              Cast to string
P               Print without moving the cursor

1সত্য এবং মিথ্যাচারের জন্য আউটপুট পরিচালনা করে 0। পরবর্তী পুনরাবৃত্তির বিরুদ্ধে ইনপুট তুলনা 13, 26, 39, 52ইত্যাদি কিন্তু প্রতিটি সময় উত্তর overprinted তাই শুধুমাত্র চূড়ান্ত উত্তরটি দেখা হয়।


1

জাভাস্ক্রিপ্ট ES6, 32 বাইট

((f=k=>n=>n>0?n==k:f(k+32))(32))

যদি সত্য হয় 0 এবং অন্য হিসাবে মিথ্যা, 31 বাইট

(f=k=>n=>n>0?n-k:_=>f(k+_))(31)

console.log([
    ((f=k=>n=>n>0?n==k:f(k+32))(32)) (31),
    ((f=k=>n=>n>0?n==k:f(k+32))(32)) (32),
    ((f=k=>n=>n>0?n==k:f(k+32))(32)) (33),
    ((f=k=>n=>n>0?n==k:f(k+32))(32)) (64),
    ((f=k=>n=>n>0?n==k:f(k+32))(32))((f=k=>n=>n>0?n==k:f(k+32))(32)) (32),
    ((f=k=>n=>n>0?n==k:f(k+32))(32))((f=k=>n=>n>0?n==k:f(k+32))(32)) (63),
    ((f=k=>n=>n>0?n==k:f(k+32))(32))((f=k=>n=>n>0?n==k:f(k+32))(32)) (64),
    ((f=k=>n=>n>0?n==k:f(k+32))(32))((f=k=>n=>n>0?n==k:f(k+32))(32))((f=k=>n=>n>0?n==k:f(k+32))(32)) (96)
]);


1

এমআইপিএস, 4 বাইট

$a0আর্গুমেন্ট এবং রিটার্ন মান হিসাবে ব্যবহার করে ।

0x2084fffc    addi $a0, $a0, -4

এমআইপিএস, 8 বাইট (এমআইপিএস কলিং কনভেনশন ব্যবহার করে)

0x2084fff8    addi $a0, $a0, -8
0x00041021    move $v0, $a0

x86, 5 বাইট

এটি আমার প্রথম x86 উত্তর তাই প্রতিক্রিয়া স্বাগতম। প্রথম আর্গুমেন্ট হিসাবে ইক্যেক্সের সাথে _ফেসকাল কলটি ব্যবহার করুন Uses

83 e9 05                sub    $0x5,%ecx
89 c8                   mov    %ecx,%eax

মন্তব্যগুলিতে পিটার কর্ডসের 1 টি বাইট সমাধান রয়েছে।


ব্রেইনফাকের ভাষ্য : হার্ড অংশটি একটি একক মান ফেরত দেওয়ার জন্য মস্তিষ্ক ফাক পাচ্ছে। অন্যথায় এরকম কিছু সহজ হবে।

- >,[-<->] < .

1
আপনার x86 কোড খণ্ডটি 32-বিট পূর্ণসংখ্যার জন্য একই আকারের হবে, 8-এর সীমাবদ্ধতার প্রয়োজন হবে না তবে আপনি যদি কাস্টম কলিং কনভেনশন (আ.এল.-তে আর্গুমেন্ট, অন্য কোথাও কোথাও কোথাও ব্যবহার করেন) ব্যবহার করেন তবে আপনি 2-বাইট AL বিশেষ ব্যবহার করতে পারেন এনকোডিং sub $4, %al/ mov %al, %dl। বা তবুও AL / EAX এ ফিরে আসুন এবং তারপরে আপনি ডেনিসের সমাধান পান dec %eax(32-বিট মোডে 1 বাইট) দিয়ে। এবং হ্যাঁ, কাস্টম কলিং কনভেনশনগুলি asm এর জন্য দুর্দান্ত। এটি asm, কেবল "asm থেকে সি থেকে কল করা সহজ" নয়; আসমে লিখিত আসল কোডটি কাস্টম কলিং কনভেনশন ব্যবহার করে যেখানে এটি সহায়তা করে তাই এটি সম্পূর্ণ ন্যায়সঙ্গত।
পিটার কর্ডস

1
এআরএমের সাধারণ কলিং কনভেনশনটি প্রথম r0যুক্তিযুক্ত যার মধ্যে বিবর্তনও রয়েছে, সুতরাং থাম্বটি sub r0, #22 বাইট।
পিটার কর্ডস

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

1
(এনভিএম, এটি% আল-এ পুনরুদ্ধারটি ছাড়বে না)। xchg %eax, %ecx/ sub $4, %al/ xchg %eax, %ecxহয় 4 বাইট, এবং _ফাস্টকাল কনভেনশন অনুসরণ করে। AL, im8 এবং xchg-e-eax শর্ট এনকোডিংগুলি প্রায়শই কোড গল্ফের জন্য সহায়ক।
পিটার কর্ডস

1
আমি সাধারণত objdump -drwC -Mintelমেশিন-কোড বাইটের একটি হেক্সডাম্প পেতে ব্যবহার করি । add r32, imm83 বাইটও হয়: অপকোড + মোডিআর / এম + ইমি 8। সমস্ত নির্দেশিকা যা একটি ইমিউন 32 নিতে পারে তার বিকল্প অপকোড থাকে যা একটি সাইন-এক্সটেন্ডেড ইমিউন নেয়। উদাহরণস্বরূপ felixcloutier.com/x86/ADD.html দেখুন ; 8086-র পূর্ববর্তী সমস্ত "ক্লাসিক" ALU নির্দেশাবলী (তবে MOV নয়) এর মধ্যে সমস্ত মডেল / এম ছাড়া বিশেষ AL / AX / EAX রয়েছে এমন সমস্ত এনকোডিং রয়েছে, কেবল ওপ + + এমএম 8/16/32। এই উত্তরের উদাহরণ রয়েছে
পিটার কর্ডেস

1

অক্টাভা: 23 বাইট

+23;[ans,i]((N==ans)+1)

যদি এন = এল * এম হয় তবে এক্সপ্রেশনটি প্রত্যাবর্তন করে 0+i(অর্থাত্ একটি নিখুঁত কল্পিত সংখ্যা), অন্যথায় অভিব্যক্তিটির ফলাফল একটি আসল উপাদান সহ জটিল সংখ্যায়।

অতিরিক্ত বাইটের দামে কিছুটা ভাল ফলাফলের জন্য:

+24;[ans,-1]((N==ans)+1)

যদি এন = এল * এম এক্সপ্রেশনটি ফিরে আসে -1, অন্যথায় একটি ধনাত্মক সংখ্যা।

ডেমো:

N=48;
+24;[ans,-1]((N==ans)+1)                                                 #>> 24 
+24;[ans,-1]((N==ans)+1)+24;[ans,-1]((N==ans)+1)                         #>> -1
+24;[ans,-1]((N==ans)+1)+24;[ans,-1]((N==ans)+1)+24;[ans,-1]((N==ans)+1) #>> 23

পিএস, আপনি একই ফলাফলটি পেতে পারেন +24;if N==ans;-1;end;ansতবে বাইটকাউন্ট একই


1

লুয়া, 56 46 বাইট

a=(a or io.read())-46io.write(a<=0 and a or"")

সমান হলে 0 (আউটপুটস ট্রেলিং নিউলাইন) আউটপুটস যদি হয় না হয় তবে কিছু না হয় বা নেতিবাচক সংখ্যাগুলির সিরিজ (কিছু ক্ষেত্রে শূন্যের পূর্ববর্তী) সমান না হলে।

একা: অনলাইনে চেষ্টা করে দেখুন!

একগুচ্ছ বার বার: অনলাইনে চেষ্টা করে দেখুন!

ব্যাখ্যা

a=(a or io.read())-46

প্রথম পুনরাবৃত্তিতে (যখন aএখনও সংজ্ঞায়িত করা হয়নি এবং তাই তাই nil) a, অন্যথায় নিজের কাছে ইনপুট থেকে নেওয়া সংখ্যায় সেট করে। উভয় ক্ষেত্রেই 46 এর পরে বিয়োগ করা হয় a

io.write(a<=0 and a or"")

এটি কেবল a(যদি ইনপুট মোট দৈর্ঘ্যের চেয়ে বড় ছিল) বা শূন্যের সমান ক্ষেত্রে এবং অন্যথায় খালি স্ট্রিংয়ের চেয়ে কম তবে এটি মুদ্রণ করে।

-10 মনে রাখার জন্য বাইটস যে লুয়া স্বয়ংক্রিয়ভাবে সংখ্যা এবং স্ট্রিংয়ের মধ্যে রূপান্তর করে। উপস।


0

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

এই হিসাবে একই কৌশল ব্যবহার করছে বেনইট Esnard মধ্যে এই উত্তর (থেকে আমি উৎস দ্বিগুণ, আপনি আউটপুট দ্বিগুণ! )।

প্রিন্ট 0 যদি n = 47 * এম , বা অন্যথায় একটি শূন্য মান।

n=prompt(setTimeout`alert(n)`)-47/*
n-=47//*///

এম = 1 এর জন্য ডেমো

n=prompt(setTimeout`alert(n)`)-47/*
n-=47//*///

এম = 2 এর জন্য ডেমো

n=prompt(setTimeout`alert(n)`)-47/*
n-=47//*///n=prompt(setTimeout`alert(n)`)-47/*
n-=47//*///


0

ব্রেন-ফ্লাক , 24 বাইট

({}[(((()()()){}){}){}])

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

ইনপুট থেকে কেবল 24 টি বিয়োগ করে। 0সত্যের ফলস্বরূপ এবং মিথ্যের জন্য অন্য কিছু।

ব্রেন-ফ্লাক , 68 বাইট

{<>}<>(({}[((((()()()()){}){}()){}){}])<>{})((){[()](<{}<>>)}{}<>{})

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

এটি একটিকে আরও পরিশীলিত এটি 1সত্য এবং 0মিথ্যা বলে আউটপুট দেয় ।

আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.