গণিত সত্য। প্রোগ্রামিং হয় না

175

গণিতশাস্ত্রে একটি বিস্ময়বোধক চিহ্ন !প্রায়ই মানে গৌণিক এবং এটি যুক্তি পর আসে।

প্রোগ্রামিংয়ে একটি বিস্মৃত চিহ্নটির !অর্থ প্রায়শই প্রত্যাখ্যান এবং এটি যুক্তির আগে আসে।

এই চ্যালেঞ্জের জন্য আমরা এই অপারেশনগুলি কেবল শূন্য এবং একটিতে প্রয়োগ করব।

Factorial
0! = 1
1! = 1

Negation
!0 = 1
!1 = 0

শূন্য বা তার বেশি একটি স্ট্রিং নিন !'র, দ্বারা অনুসরণ 0বা 1, শূন্য বা তার বেশি দ্বারা অনুসরণ !' গুলি ( /!*[01]!*/)।
উদাহরণস্বরূপ, ইনপুটটি !!!0!!!!বা !!!1বা !0!!বা 0!বা হতে পারে 1।

!'এর আগে গুলি 0বা 1হয় negations এবং !পরে গুলি ফ্যাক্টরিয়ালগুলির হয়।

কারখানার অবজ্ঞার চেয়ে বেশি অগ্রাধিকার রয়েছে তাই সবসময় ফ্যাক্টরিয়ালগুলি প্রয়োগ করা হয়।
উদাহরণস্বরূপ, !!!0!!!!সত্যিকারের অর্থ !!!(0!!!!), বা আরও ভাল !(!(!((((0!)!)!)!)))।

সমস্ত ঘটনামূলক এবং অবহেলার ফলাফল প্রয়োগ করে। আউটপুট সর্বদা 0বা হবে 1।

পরীক্ষার মামলা

0 -> 0
1 -> 1
0! -> 1
1! -> 1
!0 -> 1
!1 -> 0
!0! -> 0
!1! -> 0
0!! -> 1
1!! -> 1
!!0 -> 0
!!1 -> 1
!0!! -> 0
!!!1 -> 0
!!!0!!!! -> 0
!!!1!!!! -> 0

বাইটের মধ্যে সংক্ষিপ্ততম কোডটি জয়ী।

code-golf  string  math  logic  factorial 
— ক্যালভিনের শখ
সূত্র
18
তবে 0! = 1!, তাই একাধিক ফ্যাক্টরিওলগুলি পরিচালনা করার কী লাভ?
— boboquack
30
পছন্দ করুন
— ক্যালভিনের
11
? <= '1'; ... পিএইচপি সময়ে 75% সময় সঠিক করুন।
— aslum
10
আমি এখানে ভুল হতে পারি তবে কোনও ফ্যাকটোরিয়াল দিয়ে কোনও সংখ্যা সহজেই সরানো এবং 1 এর সাথে প্রতিস্থাপনের পরে করা যাবে না? 0 টি পছন্দ = 1 !! = 0 !!!!!!!! = 1 !!! = 1! = 0! = 1 ইত্যাদি
— অ্যালবার্ট রেনশো
2
পছন্দ করুন
— ক্যালভিনের

উত্তর:

43

গণিত, 25 17 বাইট

Input[]/.!x_:>1-x

কোনও ব্যবহারকারী প্রম্পট থেকে ইনপুট নেয়। অন্তর্নিহিত মুদ্রণের জন্য গণিতের নোটবুক পরিবেশ অনুমান করে । এটিকে একটি কমান্ড-লাইন স্ক্রিপ্ট তৈরি করতে, এটিকে মোড়ানো Print[...]বা এটি একটি যুক্তিহীন ফাংশন করতে (যা প্রম্পট থেকে ইনপুট নেয়), অ্যাপেন্ড করুন &।

গাণিতিকের উভয় প্রয়োজনীয় অপারেটর রয়েছে (প্রয়োজনীয় নজির সহ), সুতরাং আমরা কেবল ইনপুটটি "বিস্মিত" করতে পারি (যা স্বয়ংক্রিয়ভাবে সম্পন্ন হয় Input[]), তবে লজিক্যাল নেগ্রেশন অপারেটরটি পূর্ণসংখ্যার উপর কাজ করে না (সুতরাং এটি অবমূল্যায়িত থাকবে)। যদি !xফলাফলের কোনও বাম থাকে, তবে আমরা এটির সাথে প্রতিস্থাপন করব 1-x।

মূল্যায়ন সম্পর্কে মজাদার কয়েকটি ঘটনা:

  1. ম্যাথামেটিকাল আসলে এছাড়াও দ্বৈত গৌণিক অপারেটর হয়েছে !!, যা নির্ণয় n*(n-2)*(n-4)*...কিন্তু প্রয়োগ 0বা 1এটি এখনও দেয় 1, তাই এটা কোন ব্যাপার না যে 0!!!!!আসলে যেমন বিশ্লেষণ করা হবে ((0!!)!!)!।
  2. যদিও গাণিতিক পাতা !0এবং !1অমূল্য, এটি জানে যে !স্ব-বিপরীত, তাই এটি স্বয়ংক্রিয়ভাবে সমস্ত জোড়া লিডিং বাতিল করে দেবে !। পরে ToExpressionআমরা করছি সবসময় এক সঙ্গে বাম 0, 1, !0, !1।
— মার্টিন ইন্ডার
সূত্র
3
কখন থেকে একটি রেইপিএল স্নিপেটটি ডিফল্টরূপে অনুমোদিত হয়েছিল?
— LegionMammal978
2
@ লিজিয়নম্যামাল978 স্পষ্টত ডিসেম্বর 2015 থেকে, তবে আমি এটি ভুলে যেতে থাকি। সত্য কথা বলতে গেলে, এটি কোনও "স্নিপেট" নয় যে এটি অনুমান করে না যে ইনপুটটি ইতিমধ্যে মেমরিতে কোথাও সঞ্চিত রয়েছে। এবং ধরে নেওয়া নোটবুকের পরিবেশটি তখন অন্তর্নিহিত আউটপুট সহ কোনও ভাষা থাকা থেকে খুব আলাদা নয়।
— মার্টিন ইন্ডার
শুধু কৌতূহলী, একটি মেটা লিঙ্ক সরবরাহ করা যেতে পারে? (তথ্যের জন্য তথ্যের সন্ধান করার চেষ্টা করছেন, তবে এসই প্রশ্নোত্তর বিন্যাসের আর একটি সমস্যা ...)
— লেজিওনম্যামাল 978
@ LegionMammal978 এটি ইতিমধ্যে উত্তরে রয়েছে।
— মার্টিন ইন্ডার
খাঁটি ksh সমাধান x=${x/[01]!*/1};echo $(($x))- একটি সঠিক উত্তর পোস্ট করার অনুমতি নেই :(
— ডার্কহার্ট
28

[বাশ] + ইউনিক্স ইউটিলিটিস, 21 17 বাইট

sed s/.!!*$/1/|bc

এটি অবশ্যই একটি ফাইলে সংরক্ষণ করতে হবে এবং একটি প্রোগ্রাম হিসাবে চালানো উচিত। আপনি যদি কমান্ড লাইন থেকে সরাসরি কমান্ডটি প্রবেশ করার চেষ্টা করেন, এটি কাজ করবে না কারণ !! বাশের ইন্টারেক্টিভ মোডে ইতিহাস প্রতিস্থাপন সক্ষম হওয়ার কারণে প্রসারিত হয়। (বিকল্পভাবে, আপনি ইতিহাসের বিকল্পটি বন্ধ করে দিতে পারেন set +H))

পরীক্ষার কেস চলছে:

for x in 0 1 '0!' '1!' '!0' '!1' '!0!' '!1!' '0!!' '1!!' '!!0' '!!1' '!0!!' '!!!1' '!!!0!!!!' '!!!1!!!!'; do ./excl <<<"$x"; done

0
1
1
1
1
0
0
0
1
1
0
1
0
0
0
0
— মিচেল স্পেক্টর
সূত্র
পুরানো সংস্করণটি কাজ করে, এটি কোনও হয় না
— গরু
আমি টিআইও লিঙ্কটি ব্যবহার করেছি
— ows
@ ক্রিটিক্সিলিথোস যখন আমার লিনাক্স বাক্সে চেষ্টা করেছিলাম তখন এটি কার্যকর হয়েছিল। সমস্যাটি স্পষ্টতই ছিল যে সিমুলেটেড ইনপুট লাইনের শেষে টিআইওর জন্য একটি নতুন লাইন প্রয়োজন। এটি একটি বিভ্রান্তিকর পরিস্থিতি, তাই আমি টিআইও লিঙ্কটি বের করেছিলাম। আপনি যদি এটি চেষ্টা করে দেখতে চান তবে এখানে লিঙ্কটি আবার দেওয়া হয়েছে (তবে এটি পরীক্ষা করার জন্য যদি আপনি ইনপুটটি পরিবর্তন করেন তবে ইনপুটটির
— মিচেল স্পেক্টর
2
তবে কেউ যদি দৌড়ায় mkdir -p 's/.!!'{bunch,of,different,directories}\$/1? তারপরে আপনি পাথনাম এক্সপেনশন পাবেন এবং সেড স্ট্যান্ডার্ড ইনপুট পড়ার পরিবর্তে ডিরেক্টরিগুলি ফাইল হিসাবে পড়ার চেষ্টা করবেন এবং এটি কোনও ফলাফল দেবে না! :)
— ওয়াইল্ডকার্ড
1
@ উইল্ডকার্ড আমি সম্পূর্ণরূপে একমত উত্পাদনের স্ক্রিপ্টগুলিতে, আমি সর্বদা এ জাতীয় পরিস্থিতিতে কোট ব্যবহার করি। (এই ক্ষেত্রে, আমি কেবল * * এড়িয়ে চলার চেয়ে সেডের পক্ষে আর্গুমেন্টের চারপাশে ডাবল কোট রাখি bac ব্যাকস্ল্যাশ ব্যবহার না করে পড়া সহজ, এবং এটি কিছু বিশেষ চরিত্র হারিয়ে যাওয়ার সম্ভাবনা এড়িয়ে চলে))
— মিচেল স্পেক্টর
22

রেটিনা , 20 15 14 বাইট

লিওকে 1 বাইট সংরক্ষণ করার জন্য ধন্যবাদ

0!
1
!!

^1|!0

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

ব্যাখ্যা

0!
1

ঘুরুন 0!মধ্যে 1। আমরা অন্য কোনও চলার বিষয় নিয়ে চিন্তা করি না !, ফলস্বরূপ সংখ্যাটি সমান হয় যেন আমরা সমস্ত ফ্যাকটোরিয়াল প্রয়োগ করেছি।

!!

অস্বীকৃতি জোড় বাতিল। এটি কিছু ফ্যাকটোরিয়ালগুলি বাতিলও করতে পারে তবে এটি অপ্রাসঙ্গিক।

^1|!0

এই রেজেক্সের মিলগুলির সংখ্যা গণনা করুন, যা হয় 1বা হয় 0এবং পছন্দসই ফলাফল দেয়।

— মার্টিন ইন্ডার
সূত্র
একই bytecount জন্য একটি বিকল্প সমাধান: \d.+...
— গরু হাতুড়ে
নিখুঁতভাবে সম্পূর্ণ এড়ানোর জন্য একটি উপায় খুঁজে পেয়েছেন ক্রিটিক্সিলিথোস।
— মার্টিন ইন্ডার
আপনি অপসারণ করতে পারেন ^আগে!0
— লিও
17

গ্রিম , 14 12 9 বাইট

e`\0!~\!_

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

ব্যাখ্যা

এটি কোনও প্যাটার্নের সাথে ইনপুট 1মেলে , ম্যাচের জন্য মুদ্রণ এবং 0কোনও মিল নেই।

e`\0!~\!_
e`         Match entire input against this pattern:
    !      not
  \0       a sole 0
     ~     xor
      \!   exclamation mark
        _  followed by this pattern matched recursively.

ধারণাটি এই। যদি ইনপুটটি কোনও অঙ্ক দিয়ে শুরু হয়, তবে পুনরাবৃত্তির অংশটি \!_সর্বদা ব্যর্থ হয় এবং \0!আমাদের একটিও না থাকলে সফল হয় 0। ইনপুটটি একক না হলে তাদের জোর সফল হয় 0। যদি ইনপুটটি একটি দিয়ে শুরু হয় !, তবে \0!সর্বদা সফল হয় এবং \!_পুনরাবৃত্তির ম্যাচ সফল হলে সফল হয়। যখন পুনরাবৃত্তির ম্যাচটি ব্যর্থ হয় ঠিক তখনই তাদের জোর সাফল্য লাভ করে neg

— Zgarb
সূত্র
16

ব্রেইনফাক, 85 72 (84) বাইট

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

সংখ্যায় ফিরে আসতে, বা

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

ASCII পাঠ্যের জন্য। > মেমরি মোড়ানো এড়াতে উপসর্গও করা যেতে পারে।

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

Loops over the input.
On 1, ends.
On "!", toggles bool a stored as 0 or 255.
On "0", toggles if there is no trailing bit, then ends.

Memory labels  | BOOL | INPUT | FLAG |

,                   first input 
[                     # loop on INPUT
  >-[-----<->]<++     subtract 49 == "1"

  [                     # case not "1"
    >++++[-<++++>]      add 16 since 49 take 16 == "!"

    +                   set FLAG
    <                   move to INPUT
    [                     # case "0"
      [+],                clear and new INPUT
      [                     # case "0!"
        [-]>-<              clear INPUT and FLAG
      ]
    ]
  ]

  >                   move to FLAG
  [                     # case "!" or "0" without tail
    <<+[-->]>[<]        not the BOOL
    ,                   take new input
    >-                  clear FLAG
  ]
  <                   move to INPUT
]

+.                    return 0 or 1

বা পাঠ্য প্রতিক্রিয়ার জন্য, এর সাথে শেষ লাইনটি প্রতিস্থাপন করুন 

-[-----<+>]<--.       add 49 for "0" or "1" conversion and return
— রবার্ট সমাধি
সূত্র
14

ব্রেইনফাক - অনেকগুলি বাইট (232 বাইট)

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

>>>>>,[>+++[<---------------->-]<<<<<<[-]+>[-]>>>>[-[<<[>+<<<<->>>[<<+>>-] ]<<[>>+<<-]<[>>+<<[-]]>>>>>[-]]<<<<<[>>>++<<<-]>+>>>>[-]]<<<<-[>>+<<[-]]>>>>,]<<->[<[-]+>[-]]<<[<[-]>>[<<+>>[-]]+<<[->>-<<]>-]>>[-]+++[<++++++++++++++++>-]<.
— CodyCode
সূত্র
3
তুই পাগল মানুষ !!
— আলমো
এটাকে ভালোবাসি, আপনি কি ম্যালবলেজে এটি করতে পারবেন? এক্সডি
— স্টিফান নলদে
তথ্য: নীচে খুব বেশি সংক্ষিপ্ত সমাধান রয়েছে।
— ব্যবহারকারী 202729
14

পাইথন, -44- 42 বাইট

Zgarb ধন্যবাদ 2 বাইট সংরক্ষণ করা!

lambda x:(x[-1]=='0')^len(x.rstrip('!'))%2

ধাপে ধাপে:

  1. x[-1]!='0'
    যদি xশেষ হয় 1বা with দিয়ে শেষ হয় না, !কারণের অংশটির মান থাকতে হবে অন্যথায়x010
  2. ^len(x.rstrip('!'))%2
    জোরের সম্পত্তিটিকে "শর্তসাপেক্ষ নয়" হিসাবে শোষণ করুন। এই ক্ষেত্রে শর্তটি যদি প্রাথমিক !গুলিগুলির দৈর্ঘ্য বিজোড় হয়। যাইহোক, .rstripস্ট্রিং থেকে সংখ্যাটি সরাবেন না যাতে গণনা করা দৈর্ঘ্য 1 দ্বারা অফসেট হয়, সুতরাং শর্তটি উল্টো হয়
  3. অফসেটটি 1 পদক্ষেপের 1 দ্বারা অফসেটটি 1 ধাপে পরিবর্তন !=করে সংশোধন করা ==হয়েছে Z জগারব আরও একটি বিপরীত প্রয়োগ না করে 2 বাইট সংরক্ষণ করে একটি পার্থক্য তুলনা অপারেটরটি ব্যবহার করার পরামর্শ দিয়েছিলেন।

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

— busukxuan
সূত্র
একটি ইনপুট ব্যর্থ !!0; এটি বর্তমানে ফিরে আসছে 1।
— মূল্য কালি
@ ভালিউইঙ্ক এখন কাজ করা উচিত
— বাসুকসুয়ান
1
lambda x:(x[-1]=='0')^len(x.rstrip('!'))%2অতিরিক্ত বিপর্যয় এড়ানো।
— জাগারব
15
ক্রস আউট 44 এখনও নিয়মিত 44
— R
3
আমার মনে হয় তিনি বলছেন যে ব্যবহৃত ফন্টের 44 টি ক্রস আউট অতিক্রম করা দেখায় না ... :) ক্রস আউট অংশ 4 এর অনুভূমিক অংশের সাথে ওভারল্যাপ হয়।
— জেফসি 16
13

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

s=>+eval(s.replace(/.!+$/,1))

নন-রেজেক্স পদ্ধতি ( 41 31 বাইট)

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

f=([c,...s])=>1/c?c|s>'':1-f(s)

পরীক্ষার মামলা

কোড স্নিপেট দেখান

— Arnauld
সূত্র
আমি শুধু আপনার অ-Regex পদ্ধতি থেকে 10 বাইট সংরক্ষণ করতে পারবেন, তাই এটি এখনও খুব দীর্ঘ: f=([c,...s])=>1/c?c|s>'':1-f(s)।
— নীল
@ নীল যেহেতু এটি আমার প্রথম প্রয়াসের চেয়ে অনেক ভাল, তাই আপনার পরামর্শটি অন্তর্ভুক্ত করার জন্য আমি স্বাধীনতা নিয়েছি।
— আর্নল্ড
হা, আমি একই ধারণা ছিল কিন্তু আপনি এটি আরও ভাল গল্ফ। :)
— দেবসমান
11

জেলি , 5 বাইট

VeMḂ$

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

স্ট্রিং প্রত্যাশী মোনাডিক ফাংশন। শীর্ষে রয়েছে ইনপুট !গুলি কারণ একটি 1পথ ধরে stdout- এ ছাপা হবে, তাই Tio লিংক আমি দিতে একটি পরীক্ষা সাজ যে আউটপুট প্রথম লাইন তলদেশে ইনপুট-আউটপুট জোড়া ছাপে হয়।

কিভাবে?

VeMḂ$ - Monadic link: string
V     - eval the string
          - the implicit input of 0 causes !...! to evaluate to 1 (which gets printed),
          - the result is the evaluation of the rest: "0"=0; "0!"=1; "1"=1; "1!"=1; ...
 e    - exists in?
    $ - last two links as a monad:
  M   -     Maximal indexes - the "0" and "1" characters are greater than "!",
                            - so this results in a list of one item [i] where
                            - i is the 1-based index of the 0 or 1 character.
   Ḃ  -     %2 (vectorises) - [i%2], so a 0 if we need to logically negate and a 1 if not
                            - hence we check equality with e rather than inequality.
— জোনাথন অ্যালান
সূত্র
10

05 এ বি 1 ই , 9 বাইট

কোড:

.V¹'!ÜgG_

সিপি -1222 এনকোডিং ব্যবহার করে । এটি অনলাইন চেষ্টা করুন! বা সমস্ত পরীক্ষার কেস যাচাই করুন!

ব্যাখ্যা:

.V         # Evaluate the input as 05AB1E code. This computes the factorial part.
   '!Ü     # Remove trailing exclamation marks..
  ¹        # ..from the first input
      g    # Get the length of the resulting string
       G   # Do the following length - 1 times:
        _  #   Negate the number
— আদনান
সূত্র
10

রেটিনা , 13 বাইট

কিছুটা অদ্ভুত পদ্ধতি, তবে এটি সংক্ষিপ্ত এবং এটি কার্যকর works

0$
!1
!!

^\d

প্রথম দুই লাইন সঙ্গে আমরা শেষের প্রতিস্থাপন 0সঙ্গে !1: এই প্রতিস্থাপন সঙ্গে আমরা এখন জানি যে অঙ্ক থেকে আমাদের স্ট্রিংয়ের অংশকে অগ্রে 1 সমান।

পরবর্তী দুটি লাইন, এর জোড়া সরিয়ে ফেলুন !: ডাবল অস্বীকৃতি নিজেই মুছে যায় এবং আমরা ইতিমধ্যে পূর্ববর্তী পদক্ষেপের সাথে ফ্যাক্টরিয়াল হিসাবে জবাবদিহি করেছি।

শেষ লাইনটি, স্ট্রিংয়ের শুরুতে একটি অঙ্কটি মেলে এবং ম্যাচের সংখ্যাটি ফিরিয়ে দিন: যদি সমস্ত উপেক্ষাগুলি দূর হয়ে যায় তবে আমরা একটি মিল খুঁজে পাই (এবং আমরা আগেই বলেছিলাম যে এটি 1 এর সমান) তবে এখনও আছে একটি অবহেলা এই মেলে না।

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

— সিংহরাশি
সূত্র
1
চূড়ান্ত অঙ্কটি সর্বদা 1 হবে না? সেক্ষেত্রে আপনি 1বরং ব্যবহার করতে পারবেন \d।
1
@ আইস ৫২৩ না, কারণ প্রথম অংশটি কেবল একটি শেষ 0 টি প্রতিস্থাপন করবে, সুতরাং উদাহরণস্বরূপ ইনপুটটি 0!শেষ পংক্তির অবধি অপরিবর্তিত থাকবে
— লিও
1
সত্যিই সুন্দর সমাধান, দুর্দান্ত কাজ! :)
— মার্টিন এন্ডার
10

রুবি, 12 + 1 = 39 24 15 13 বাইট

-nপতাকা ব্যবহার করে । @ জিবি -9 বাইটের জন্য ধন্যবাদ !

p~/!*$|0$/%2
— মান কালি
সূত্র
যেহেতু আপনি কেবল দৈর্ঘ্য পরীক্ষা করেছেন, আপনি প্রথমে "! 0" এবং তার পরে একক শূন্যের পরিবর্তে পিছনের শূন্যটি মুছতে পারেন।
— জিবি
@ জিবি এটি একটি দুর্দান্ত ধারণা! যাইহোক, আমি এমন একটি সমাধান পেয়েছি যা আমার রেজেক্সকে সংশোধন করে লাইনটির শেষের 0 বা শেষের অবস্থানটি অনুসন্ধান করে
— মান কালি
তারপরে আপনি কেবল 'পিছনে' পরীক্ষা করতে পারেন! ' বা শূন্য বা রেখার শেষ: p ~ /! + $ | 0 $ | $ /% 2 কেবল 14 বাইট।
— জিবি
এবং তারপরে "0 $ | $" অন্য বাইট সংরক্ষণ করতে "0? $" হয়ে উঠতে পারে।
— জিবি
1
আরও !*$দু'জনের চেয়ে আরও খাটো!
— মান কালি
9

পার্ল , 20 বাইট

কোড + -pপতাকা 19 বাইট ।

s/\d!+/1/;$_=0+eval

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

পার্লের প্রত্যাখ্যান ফিরে আসে undefবা 1, তাই আমি 0+ফলাফলের 0+undefরিটার্নগুলিকে অঙ্কের জন্য ব্যবহার করি 0। তা ছাড়া কোড সম্পর্কে বেশি কিছু বলার নেই much

— দাদা
সূত্র
2
ঠিক ঠিক এই লিখেছেন। একটি +1 আছে।
— প্রিমো
@ প্রিমো খুশি যে একবারের জন্য আমি আপনার পিছনে 20 বাইট না! ধন্যবাদ :)
— দাদা
9

সি, 68 62 61 53 বাইট

c;e(char*a){for(c=1;*a<34;a++)c^=1;c=a[1]?c:*a&1^!c;}

কিছু গালাগাল করে আরও কিছু বাইট বের করে আনে

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

— Ahemone
সূত্র
1
আমি মনে করি আপনি intফাংশনটি থেকে অপসারণ করতে পারেন এবং আপনি এতে পরিবর্তন করতে *a==33পারেন *a<34।
— গরু 18
হায় *a%2হ'ল সংক্ষিপ্ত*a-48
— গরুরা
ভকভগক. আমি রিটার্নের চারপাশে বন্ধনীগুলি সরিয়ে এবং এটি বরাদ্দ করে অন্য একটি চরিত্রকে মুছে ফেলতে সক্ষম হয়েছি।
— আহেমোন
আমি নিশ্চিত যে 1 বাইট বাঁচিয়ে for(;*a<34;a++)ছোট করা যেতে পারেfor(;*a++<34;)
— অ্যালবার্ট রেনশো
দুর্ভাগ্যক্রমে নয়, শর্তসাপেক্ষ বিবৃতি হিসাবে এটি সর্বদা কার্যকর করা হবে এবং তাই প্রত্যাবর্তনের ছাড়ের জন্য পয়েন্টারটিকে অনেক দূরে ঠেলে দেবে।
— আহেমোন
6

পার্ল 6 , 32 28 23 বাইট

{m/(\!)*(1|0.)*/.sum%2}

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

{                     }  # A lambda.
{m/            /      }  # Match the lambda argument against the regex:
   (\!)*                 #   Zero or more `!`.
                         #     (First capture will be an array with one element per negation).
        (1|0.)*          #   A `1`, or a `0` and another character, zero or more times.
                         #     (Second capture will be a one-element array if the factorial
                         #     part evaluates to 1, and an empty array otherwise.)
                .sum     # Add the lengths of the two captures,
                    %2   # and return that sum modulo 2.
— smls
সূত্র
6

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

f('!':b)="10"!!read[f b]
f[a]=a
f _='1'

একটি ফাংশন সংজ্ঞায়িত করে f, যা একটি স্ট্রিং নেয় এবং একটি অক্ষর দেয়। এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

তিনটি কেস রয়েছে: ইনপুট দিয়ে শুরু হয় !, ইনপুটটির দৈর্ঘ্য 1 এবং অন্য সব কিছু।

f('!':b)=    -- If input has head '!' and tail b,
 "10"!!      -- we index into the string "10"
  read[f b]  -- using f b converted to int. This essentially inverts f b.
f[a]=        -- If input has only one character, we know it's a digit,
 a           -- so we can just return it.
f _=         -- In all other cases, we know the input is a digit followed by !s,
 '1'         -- so we can return '1'.
— Zgarb
সূত্র
রিটার্ন টাইপ হিসাবে পূর্ণসংখ্যা স্ট্রিং থেকে স্যুইচ করুন: f('!':b)=[1,0]!!f b;f"0"=0;f _=1।
— নিমি
6

বেফুঞ্জ, 24 বাইট

~"!"-:#v_$1+
*+2%!.@>0~`

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

এটি !স্ট্ডিন থেকে পড়া অক্ষরের সংখ্যা গণনা করে শুরু হয় । প্রথম চরিত্রটি যা !উইল নয় তা হয় 0বা হবে 1, তবে পরীক্ষার প্রক্রিয়ায় !আমরা 33 টি বিয়োগ করব, এটি 15 বা 16 হয়, আমরা তখন আরও একটি চরিত্র পড়ি, তা হয় হয় একটি !বা ইওএফ, এবং যদি এটি 0 (যেমন EOF) এর চেয়ে কম হয় তবে তুলনা করুন।

এই তিনটি ডাটা পয়েন্ট গ্রহণ করে - উদ্দীপনা গণনা ( সি ), অঙ্কের মান, ( d ), এবং ফাইল-এর শর্ত ( ঙ ) - আমরা ফলাফলটি নিম্নরূপে গণনা করতে পারি:

!((c + d*e) % 2)

ফাইল-শর্তের শেষে অঙ্কের মানকে গুণিত করার অর্থ হ'ল এটির শূন্যে রূপান্তরিত হবে যদি !অঙ্কটি একটি দ্বারা অনুসরণ করা হয় , সুতরাং এটি একই মডুলো 2 মানকে 1(যা মনে রাখবে 16 এ রূপান্তরিত হয়েছে) giving তবে মডুলো 2 প্রয়োগ করার আগে আমরা প্রাথমিক বিস্ময়বোধের গণনা যুক্ত করি, যা কার্যকরভাবে মডুলো 2 ফলাফলকে !উপসর্গ হিসাবে যতবার টোগল করে। এবং পরিশেষে আমরা না আমাদের বেসলাইন মান যেহেতু ফলাফলের 0এবং 1আমরা যা প্রয়োজন বিপরীত।

আরও বিশদে কোডটি দেখুন:

~                Read a character from stdin.
 "!"-            Subtract 33 (ASCII for '!').
     :  _        Make a duplicate and check if zero (i.e. is it a '!').
         $1+     If so, drop the duplicate, increment a counter, and repeat.
       v         Otherwise move to the second line, leaving the digit value on the stack.
       >0~`      Read one more character and check if less than 0 (i.e. EOF).
*                Multiple by the digit value, making it zero if not followed by EOF.
 +               Add to the exclamation count.
  2%             Modulo 2 the result.
    !            Then not that value.
     .@          And finally write to stdout and exit.
— জেমস হোল্ডারেন্স
সূত্র
6

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

f('!':b)=1-f b
f"0"=0
f _=1

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

প্রতিটি নেতৃস্থানীয় !বাকী এক্সপ্রেশন হিসাবে আউটপুট সম্পূর্ণ করে 1-। আমরা একটি অঙ্ক আঘাত না করা পর্যন্ত আমরা উল্টাতে থাকি তাহলে অবশিষ্ট ঠিক হয় "0", ফলে 0. অন্যথায় এটি একটি আছে, 1অথবা এক বা একাধিক দ্বারা অনুসরণ করা হয় !, তাই ফলাফলের 1।

— xnor
সূত্র
5

রুবি, 22 21 20 বাইট

->s{(s=~/!*$|0$/)%2}

ব্যাখ্যা:

  • প্রথম ঘটনাটি, আমি কিছু পেয়েছি! ' শেষে, এগুলি সরান, দৈর্ঘ্য মডুলো 2 পান।
  • দ্বিতীয় কেস, না '!', শেষ বর্ণটি যদি শূন্য হয় তবে এটি সরিয়ে ফেলুন, দৈর্ঘ্যের মডুলো 2 পাবেন
  • শেষ চরিত্রটি যদি 1 হয় তবে প্রথম ক্ষেত্রে ফিরে আসুন

(-1 বাইট চুরি @ ভ্যালু কালি এর ধারণা)

— গিগাবাইট
সূত্র
দুর্দান্ত, আমি এই ধাঁধাটি 10 ​​মিনিটের জন্য দেখেছিলাম কিন্তু বেশি সময় ছিল না এবং তারপরে এটি ভুলে গিয়েছিলাম। এখন এটিকে সক্রিয় প্রশ্নে আবার স্পষ্ট করেছে এবং এইরকম দুর্দান্ত পদ্ধতির বিষয়টি দেখে আনন্দিত হয়েছিল।
— akostadinov
4

জেলি , 8 বাইট

œr”!LḂ=V

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

এটি একটি ফাংশন (monadic লিঙ্ক) যা একটি যুক্তি গ্রহণ করে এবং তার ফেরতের মূল্যের মাধ্যমে ফেরত দেয়। (এটি প্রায়শই পার্শ্ব প্রতিক্রিয়া হিসাবে স্ট্যান্ডার্ড আউটপুটে জাঙ্কটি লেখেন, তবে আমরা এটির যত্ন নিই না))

ব্যাখ্যা

œr”!LḂ=V
œr”!      Take {the input}, with all trailing ! deleted
    L     Take the length of this
     Ḃ    Take the parity of that length
      =   Return 0 if unequal, 1 if equal to:
       V    the value of {the input} when eval'ed as a niladic Jelly program

প্রথম, নোট করুন যে ইনপুটটি সর্বদা কিছু সংখ্যক সমন্বিত থাকে !, তার পরে আরও একটি অঙ্ক থাকে, !আমরা যদি অনুসরণটি মুছতে !এবং দৈর্ঘ্যটি গ্রহণ করি তবে আমরা !প্রোগ্রামের শীর্ষস্থানীয় সংখ্যার সাথে শেষ করব end এর সমতুল্যতা গ্রহণ করা যদি 0 টির মধ্যে বিজোড় সংখ্যা !থাকে বা 1 এমনকি যদি সংখ্য সংখ্যা থাকে তবে 1 ফিরে আসবে !। 0 এর সাথে তুলনা করা একটি "না" ফাংশন, যেখানে 1 এর সাথে তুলনা করা হচ্ছে পরিচয় ফাংশন; সুতরাং œr”!LḂ=কার্যকরভাবে !প্রশ্নের আচরণের অংশ হিসাবে "অপারেটর হিসাবে নেতৃত্বদান না করা " কার্যকর করে ।

দ্বিতীয়ার্ধের মতো, !ফ্যাক্টরিওলগুলি পরিচালনা করা জেলির একটি ফ্যাক্টরিয়াল অপারেশন, সুতরাং যদি প্রোগ্রামটির কোনও নেতৃত্ব না থাকে !, আমরা সমস্যাটি সরাসরি একটি সহজ eval( V) দ্বারা সমাধান করতে পারি । প্রোগ্রাম যদি না নেতৃস্থানীয় আছে !, যারা, 0 (সম্ভবত একাধিক বার) এর গৌণিক গ্রহণ যা মানক আউটপুটে প্রিন্ট করা হবে এবং বাতিল একবার একটি অঙ্ক দেখা হয় 1 একটি ফিরতি মান, উৎপাদন হিসেবে ব্যাখ্যা করা হবে; সুতরাং, প্রশ্নটিতে আমার জমা দেওয়া ফাংশনটির রিটার্ন মানের উপর তাদের কোনও প্রভাব নেই।

খুব সুন্দর এবং দুর্দান্ত ব্যাখ্যা।
— এলপেড্রো
4

পাইথন, 38 বাইট

lambda s:(s[1::2]>s[::2])^ord(s[-1])%2

TryItOnline!

একটি নামবিহীন ফাংশন একটি ইনপুট স্ট্রিং গ্রহণ করে sএবং পূর্ণসংখ্যা ফেরত দেয় 0বা 1।

s[1::2] ইনপুট স্ট্রিংয়ের একটি টুকরা যা সূচক 1 এ শুরু হয় এবং এর দুটি ধাপের আকার থাকে:
'Like this' -> 'ieti'

s[::2] অনুরূপ তবে 0 এর ডিফল্ট সূচীতে শুরু হয়:
'Like this' -> 'Lk hs'

পরীক্ষাটি (s[1::2]>s[::2])0-ভিত্তিক সূচকটি বিজোড় '0'বা '1'বিজোড়, যদি আমাদের পরিপূরক প্রয়োজন হয় তা পরীক্ষা করে।
এটি কাজ করে কারণ স্ট্রিংয়ের ক্রমটি শূন্য স্ট্রিংয়ের চেয়ে বড় অ-ফাঁকা স্ট্রিংয়ের সাথে এবং এএসসিআইআই অর্ডার সহ, ডিক্সিকোগ্রাফিকভাবে পরীক্ষা করা হয় '1'>'0'>'!'। এটি সাধারণের চেয়ে কম বাইট s.index(max(s))%2।

ord(s[-1])%2যদি শেষ অক্ষর একটি নয় চেক দেখতে '0'(সেটি এখন বৈধ ইনপুট জন্য), এবং একটি পূর্ণসংখ্যা মধ্যে ফলাফল (যেহেতু একই দৈর্ঘ্য (s[-1]!='0')একটি বুলিয়ান ফিরে আসবে)।
এই কাজ করে কারণ ইনপুটের শেষ অক্ষর, s[-1]একটি হতে হবে '0', '1'অথবা '!'যা হওয়া ASCII কোড যথাক্রমে 48, 49, এবং 33 পয়েন্ট, যা 0, 1, এবং আরও 1 মডিউল 2 হয়।

^তারপর একটি bitwise একচেটিয়া বা দুই উপরে মান ক্রিয়াকলাপের সঞ্চালিত, এক ইনপুট, সঠিক যেহেতু একটি পূর্ণসংখ্যা ফেরার একটি পূর্ণসংখ্যা। বামটি সত্য হলে ডানটির পরিপূরকটি ফিরে আসে, বামটি যদি মিথ্যা হয় তবে ডানদিকে প্রয়োজনীয় হিসাবে ফিরে আসে।

— জোনাথন অ্যালান
সূত্র
4

জাভা 7, 105 82 81 বাইট

int a(char[]a){int b=0,c=0;for(;a[b++]<34;c^=1);return(b<a.length?1:a[b-1]&1)^c;}

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

পুরাতন রেজেক্স-ইশ সমাধান

int a(String a){a=a.replace("0!","1").replaceAll("1.*","1");int b=a.length()-1;return b%2^a.charAt(b)&1;}
— অকর্মা
সূত্র
2
c^=1সুপার চালাক। আমি যদি কখনও এটি দেখে থাকি তবে এটি অব্যবহৃত অপারেটর।
— অ্যাডিসন ক্র্যাম্প
3

সিজেম , 12 11 বাইট

r_W='0=!\~;

এটি অনলাইন চেষ্টা করুন! পরীক্ষার স্যুট ( 1প্রতিটি সঠিক পরীক্ষার জন্য একটি প্রিন্ট করে )।

r      e# Read input.
_W='0= e# Duplicate and check whether the string ends in '0'. This is the
       e# only case in which the factorial part results in 0.
!      e# Negate this to get the actual result of the factorial part.
\      e# Swap with the input.
~      e# Evalute the input as CJam code. The leading `!` will apply the logical
       e# negations to the factorial result. The 0 or 1 will then push a junk value
       e# which is potentially negated a few times as well, by the factorials.
;      e# Discard the junk value.
— মার্টিন ইন্ডার
সূত্র
3

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

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

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

Ungolfed:

% 0: inverter count
% 1: result
% 2: if/else flag; tmpspace in inner loop 0

>1,[
    ->2++++[<-------->-]<1 subtract 33 (!)
    [ 
        % we've reached the number
        ---------------
        % now it's either 0 or 1

        % check next char; If it's not 0 then it's '!'
        % 0! = 1! = 1!...! so we only need to determine if at least one ! exists
        >2,
                [<[-]+>-]<1

        % apply inversions
        <0
        [->1
            % invert cell 1 once each iteration
                       % cell 1 is 0 or 1
            -          % cell 1 is 255 or 1
            [>+<+]     % cell 1 is 0; cell 2 is 1 iff cell 1 should be 1
            >2[-<+>]<1 % cell 1 is 1 or 0
        <0]

        % print result
        >1>++++++[-<++++++++>]<1.

        >>2+< % tape={0 r 0 1}
    ]
    >2-[ % we haven't seen the number yet
        <<0+>1,>2 % add to inverter count
        [-]
    ]<1
]
— রশ্মি
সূত্র
2

ব্যাচ, 62 বাইট

@set/ps=
@set s=%s:0!=1%
@set s=%s:!!=%
@cmd/cset/a%s:1!=1%

STDIN এ ইনপুট নেয়। ব্যাচ প্রকৃতপক্ষে !এই চ্যালেঞ্জের জন্য শীর্ষস্থানীয়কে সঠিকভাবে বোঝে , তবে পিছনে !আসার সাথে মোকাবিলা করা দরকার যা তিনটি পদক্ষেপ নেয়:

  • পরিবর্তন 0!করুন1
  • জোড়া মুছুন !!( !!এটি অঙ্কের আগেও নিরাপদ )
  • কোনও অবশিষ্ট ট্রিলিং মুছুন !(যা এখন কেবলমাত্র একটির পরে হতে পারে 1)
— নিল
সূত্র
2

আইবিএম / লোটাস নোটস সূত্র - 77 বাইট

@Eval(@Left(a;@If(@Like(a;"%1%");"1";"0"))+@If(@Ends(a;"!");"1";@Right(a;1)))

নোটস ফর্মুলার জন্য কোনও টিআইও নেই তাই সমস্ত পরীক্ষার ক্ষেত্রে স্ক্রিনশটটি নীচে দেখানো হয়:

সমস্ত পরীক্ষার কেস

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

@Eval() একটি স্ট্রিংকে এক্সপ্রেশন হিসাবে মূল্যায়ন করে

প্রথম আমরা চেক ক্ষেত্র (ইনপুট) ইনপুট স্ট্রিং যদি aরয়েছে 1বা 0এবং বাম যেটা তা যা একটি স্ট্রিং হতে হবে সমস্ত অক্ষর নিতে !অক্ষর। আমরা কত যত্ন নেই। @Eval()যে যত্ন নিতে হবে।

এরপরে আমরা !স্ট্রিংয়ের শেষে আছে কিনা তা সন্ধান করব । তাহলে সেখানে আমরা যোগ হয় 1থেকে !স্ট্রিং ( 0!এবং 1!- এটা কোন ব্যাপার না কতজন উভয় 1 !অন্যথায় আমরা শেষ অক্ষর অপরিবর্তিত যোগ কারণ তা না হয় একটি অক্ষর সেখানে শেষের দিকে রয়েছে) !এবং হয় একটি হতে পারে 1অথবা একটি 0।

আমাদের কাছে এখন একটি স্ট্রিং রয়েছে যার মধ্যে নেতৃস্থানীয় ইনভারসন প্লাস এমন সংখ্যার সংজ্ঞা রয়েছে যেখানে কোনও ফ্যাক্টরিয়াল অক্ষর রয়েছে কিনা তাই আমরা এটিকে খাওয়াতে পারি @Eval()এবং উপরের ফলাফলগুলি পেতে পারি।

— ElPedro
সূত্র
2

সেড, 36 33 31 বাইট

খাঁটি সেড, কোনও বিসি / শেল ব্যবহার নেই। জিএনইউ সেড <4.3; এ কাজ করে; বিএসডি এবং জিএনইউ 4.3+ এ 33 বাইট।

s/.!!*$/1/
:
s/!0/1/
s/!1/0/
t

আপনার সাথে পরিচিত হলে সোজাভাবে যথেষ্ট sed; যারা নন তাদের পক্ষে মন্তব্য করেছেন:

# Since 0! == 1! == 1 and factorial has precedence, just collapse any trailing "!" 
s/.!!*$/1/
# Define an anonymous label
:
# Invert 0 if needed
s/!0/1/
# Invert 1 if needed
s/!1/0/
# If a change was made, go back to the anonymous label.
t

টেস্ট:

% cat 109248.sed
s/.!!*$/1/
:l
s/!0/1/
s/!1/0/
tl
% wc -c 109248.sed
      33 109248.sed
% cat cases
0
1
0!
1!
!0
!1
!0!
!1!
0!!
1!!
!!0
!!1
!0!!
!!!1
!!!0!!!!
!!!1!!!!
% sed -f 109248.sed cases
0
1
1
1
1
0
0
0
1
1
0
1
0
0
0
0
% gsed -f 109248.sed cases
0
1
1
1
1
0
0
0
1
1
0
1
0
0
0
0
%
— কেভিন
সূত্র
আইআইআরসি কয়েকটি (সমস্ত?) সংস্করণ sedআপনাকে নাল স্ট্রিংটিকে লেবেলের নাম হিসাবে ব্যবহার করতে দেয়। আপনি যদি এটি এখানে কাজ করতে পারেন তবে এটি আপনাকে দুটি বাইট সংরক্ষণ করতে পারে। প্রকৃতপক্ষে, আমি নিশ্চিত নই যে লেবেলটি এমনকি প্রয়োজনীয়; আমি যদি কিছু মিস না করি তবে প্রথম লাইনটি আদর্শবান, সুতরাং আপনি কোনও লেবেলের প্রয়োজনের চেয়ে প্রোগ্রামের শুরুতে ফিরে যেতে সক্ষম হতে পারেন।
@ ais523 আমিও এটি ভেবেছিলাম, তবে স্পষ্টতই এটি BSD সংস্করণে কাজ করে না। ম্যান পেজটি বলে "যদি কোনও লেবেল নির্দিষ্ট না করা থাকে তবে স্ক্রিপ্টের শেষে শাখা করা হয়" এবং এমনকি আমি চেষ্টা করার পরেও এটি কাজ করে না।
— কেভিন
GNU সেড একটি লেবেলকে কেবলমাত্র :(বৈশিষ্ট্য হিসাবে নেওয়া বাগের চেয়ে বেশি) মঞ্জুরি দেয় , এক্ষেত্রে tএবং উভয়ই b! কমান্ডগুলি লেবেলের অবস্থানে চলে আসে। এছাড়াও, একটি শেড কোড অবশ্যই কমপক্ষে একটি সংস্করণের জন্য সেডের অন্যান্য ভাষার মতোই কাজ করবে, সুতরাং আপনাকে এমন কোড তৈরি করার দরকার নেই যা BSD এর জন্যও কাজ করে।
— শৈশুমারা
2

পিএইচপি 7.1, 58 55 54 37 35 বাইট

দ্রষ্টব্য: আইবিএম -850 এনকোডিং ব্যবহার করে

echo!!$argn[-1]^strspn($argn,~Ì)%2;

এভাবে চালান:

echo '!!!0!!!!' | php -nR 'echo!!$argn[-1]^strspn($argn,~Ì)%2;';echo
> 0

ব্যাখ্যা

echo
  strspn($a=$argv[1],~Ì) # Count the number of leading exclamation marks.
  % 2                    # Make 0 (even) or 1 (odd).
  ^ !!$a[-1];            # Negate with factorial part (truthy value of the 
                         # last char):
                         # - "0" is considered falsy.
                         # - "1" or "!" is considered truthy.

বদলান

  • আইবিএম -850 এনকোডিং ব্যবহার করে 3 বাইট সংরক্ষণ করা হয়েছে
  • রেজেক্সটি সামান্য পরিবর্তন করে একটি বাইট সংরক্ষণ করা হয়েছে
  • দীর্ঘ ফাংশন নাম এবং রিটার্ন ব্যতীত 17 বাইট সংরক্ষণ করা, নতুন সংস্করণ
  • ব্যবহার করে 2 বাইট সংরক্ষণ করা -R(যা $argnউপলব্ধ করে)
— aross
সূত্র
1

বিন , 24 বাইট

Hexdump:

00000000 26 4a c1 53 a0 17 53 d0 80 a0 5d 20 80 0a a1 80  &JÁS .SÐ. ] ..¡.
00000010 81 00 25 3a ae a1 ab 24                          ..%:®¡«$
00000018

সমতুল্য জাভাস্ক্রিপ্ট:

+eval(a.replace(/.!+$/,1))

আপনার পায়ের আঙ্গুলের পা বাড়ানোর জন্য দুঃখিত, আর্নল্ড ।

ব্যাখ্যা:

মধ্যে অবিন্যস্ত স্ট্রিং হিসেবে ইনপুট প্রথম লাইন লাগে a, এবং যে কোনো অঙ্ক এক বা একাধিক দ্বারা অনুসরণ প্রতিস্থাপন !সঙ্গে 1, যাতে বাকি যাবে eval'জাভাস্ক্রিপ্ট দ্বারা ঘ।

ব্যবহার করে দেখুন ডেমো , বা পরীক্ষা স্যুট

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