এই সংখ্যাটি কি ফ্যাক্টরিয়াল?


38

কাজটি

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

স্ট্যান্ডার্ড লুফোলস প্রযোজ্য।


ইনপুট

আপনাকে একটি প্রাকৃতিক নম্বর দেওয়া হবে (টাইপ Integerবা অনুরূপ)।

আপনি পূর্বনির্ধারিত পরিবর্তনশীল হিসাবে ধরে নেওয়া ছাড়া আপনি যে কোনও উপায়ে ইনপুট নিতে পারেন। ফাইল, কনসোল, ডায়ালগ বক্স ( prompt), ইনপুট বাক্স ইত্যাদি থেকে পড়ার অনুমতি রয়েছে। ফাংশন আর্গুমেন্ট হিসাবে ইনপুট এছাড়াও অনুমোদিত!


আউটপুট

আপনার প্রোগ্রামটির ইনপুট নম্বরটি কোনও প্রাকৃতিক সংখ্যার ফ্যাকটোরিয়াল কিনা তার উপর ভিত্তি করে সত্যবাদী বা মিথ্যা মান আউটপুট করা উচিত।

আপনার সত্যবাদী / মিথ্যা মানগুলি সমস্ত ইনপুটগুলির জন্য সামঞ্জস্যপূর্ণ কিনা তা নিশ্চিত করুন, অর্থাত্ যদি আপনি যথাক্রমে সত্য এবং মিথ্যা মানগুলি বোঝাতে 1 এবং 0 এর জুড়ি ব্যবহার করেন তবে আপনার প্রোগ্রামটি অবশ্যই সমস্ত ইনপুটগুলির জন্য 1 আউটপুট দিতে হবে যা সত্যবাদী মান থাকতে পারে সমস্ত ইনপুটগুলির ভুয়া মান হওয়া উচিত।

ভেরিয়েবল এ লেখা বাদে আপনি যে কোনও উপায়ে আউটপুট নিতে পারেন। ফাইল, কনসোল, স্ক্রিন ইত্যাদিতে লেখার অনুমতি রয়েছে। ফাংশন returnপাশাপাশি অনুমোদিত!

আপনার প্রোগ্রাম অবশ্যই কোনও ইনপুট জন্য ত্রুটি উত্পাদন করা উচিত!


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

Input     Output

1         Truthy (0! or 1!)
2         Truthy (2!)
3         Falsey
4         Falsey
5         Falsey
6         Truthy (3!)
7         Falsey
8         Falsey
24        Truthy (4!)
120       Truthy (5!)

বিজয়ী মানদণ্ড

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


2
ভাষা যদি কেবলমাত্র numbers 0,1 range এর পরিসরে সংখ্যাগুলিকে সমর্থন করে তবে আমি কি সর্বদা ইনপুটটি আশা করতে পারি 1?
eush77


1
4 হয়! সত্যবাদী?
tuskiomi

প্রশ্ন: আপনি আই / ও ডিফল্ট ব্যবহার করছেন না কেন?
ক্যালকুলেটরলাইন

উত্তর:


37

ব্র্যাচল্যাগ , 1 বাইট

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

ব্যাখ্যা

এটি একটি অন্তর্নির্মিত যা নিম্নলিখিত সম্পর্কের উপর জোর দেয়: এর আউটপুটটি তার ইনপুটটির ফ্যাক্টরিয়াল। আমরা কেবল এটিকে একটি সেট আউটপুট দিই এবং দেখি যে এটি ভেরিয়েবল ইনপুট সহ সফল হয় কিনা।


6
@ বেটাডেএক কারণ এটি প্রোগলে মুদ্রিত করার পদ্ধতিটি রয়েছে ( true.এটি একটি বিবৃতি এবং true
এটির

6
এটি একটি তুচ্ছ সমাধান, তবে প্রোলগের কাজ করার কারণে এটি চালাক।
এষোলং ফল


17
প্রথমে কাস্টম ভাষা, তারপরে কাস্টম এনকোডিংস ... কোড গল্ফ মারা গেছে। আমরা এই মজাদার সমস্যার পুরো পয়েন্টটি প্রথম স্থানে সম্পূর্ণরূপে বিভ্রান্ত করেছি
আলেকজান্ডার

13
@ আলেকজান্ডার কাস্টম এনকোডিংগুলি আপনি যে সমস্যার কথা বলছেন তা থেকে অপ্রাসঙ্গিক। আমি পরিবর্তে যে কোনও "বিদ্যমান" এনকোডিংটি ব্যবহার করতে পারি এবং এটি এখনও 1 বাইট হবে। এটি কেবল খুব কম পাঠযোগ্য হবে।


19

জেলি , 4 বাইট

Œ?IE

সংক্ষিপ্ত জেলি উত্তর নয়, এটি বরং দক্ষ।

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

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

Œ?IE  Main link. Argument: n

Œ?    Yield the n-th permutation of the positive integers, without the sorted tail.
      For 120, this yields [5, 4, 3, 2, 1], the tail being [6, 7, 8, ...].
  I   Increments; compute all forward differences.
      For 120, this yields [-1, -1, -1, -1].
   E  Check if all differences are equal.

2
কারণ আমাদের কোড গল্ফরা দক্ষতার বিষয়ে যত্নশীল।
Okx

12
এটি একটি বাইটের ব্যয়ে একটি নাটকীয় জটিলতার উন্নতি এবং আমি নিজেরাই যদি বলতে পারি তবে এটি বিল্ট-ইন ব্যবহার করে একটি চৌকস ব্যবহার। ¯ \ _ (ツ) _ / ¯
ডেনিস

মজার বিষয় হচ্ছে, এটি 0 এর জন্য সত্য, যখন @ লিকিউন এর 3 বাইট উত্তর, যদিও অনেক ধীর গতিতে, সঠিকভাবে 0. এর জন্য মিথ্যা প্রত্যাবর্তন করে একটি দক্ষ-সম্পাদন-সময় উত্তরে 0-র জন্য অতিরিক্ত বাইটগুলি কী মিথ্যা ফিরতে হবে?
ডেডকোড

@ ডেডকোড 0 এর জন্য চেক করতে দুটি অতিরিক্ত বাইট লাগবে। যদি নিশ্চিত না হন যে "প্রাকৃতিক সংখ্যার" ওপির সংজ্ঞাটি 0 টি অন্তর্ভুক্ত করে কিনা। পরীক্ষার কেসগুলি হয় না ...
ডেনিস

17

ECMAScript Regex , 733+ 690+ 158 119 118 (117🐌) বাইট

রেজিএক্সে আমার আগ্রহটি 4½ বছরেরও বেশি নিষ্ক্রিয়তার পরে পুনর্নবীকরণের সাথে উত্সাহিত হয়েছিল। এর মতো, আমি আরও প্রাকৃতিক নম্বর সেট এবং ফাংশনগুলির সন্ধানে অনার্য ইসকামাস্ক্রিপ্ট রিজেক্সেসের সাথে মেলেছিলাম, আমার রেজেক্স ইঞ্জিনটি পুনরায় উন্নত করতে শুরু করেছি এবং পিসিআরআইতেও ব্রাশ করতে শুরু করেছি।

আমি ECMAScript রেজেক্সে গাণিতিক ক্রিয়াকলাপগুলি নির্মাণের পরকতায় মুগ্ধ। সমস্যাগুলি অবশ্যই সম্পূর্ণ ভিন্ন দৃষ্টিকোণ থেকে যোগাযোগ করা উচিত এবং কোনও মূল অন্তর্দৃষ্টি না আসা পর্যন্ত তারা আদৌ দ্রবণযোগ্য কিনা তা অজানা। এটি কোন গাণিতিক বৈশিষ্ট্যগুলি কোনও নির্দিষ্ট সমস্যার সমাধানযোগ্য করতে ব্যবহার করতে সক্ষম হতে পারে তা খুঁজে বের করার জন্য এটি আরও বিস্তৃত নেট .ালার জন্য জোর করে।

ফ্যাক্টরিয়াল সংখ্যাগুলি মিলানো এমন একটি সমস্যা ছিল যা আমি ২০১৪ সালে মোকাবেলা করার বিষয়টি বিবেচনাও করি নি - বা আমি যদি কেবল মুহুর্তে এটি করে থাকি তবে এটি সম্ভাব্য হওয়ার সম্ভাবনা খুব কম বলে খারিজ করে দেয়। তবে গত মাসে, আমি বুঝতে পারি যে এটি করা যেতে পারে।

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

সুতরাং আপনি যদি কিছু উন্নত ইউনারি রেজেক্স যাদু আপনার জন্য নষ্ট না করতে চান তবে আর পড়বেন না । আপনি যদি এই যাদুটি নিজেই বের করে আনতে চান তবে উপরের লিঙ্কযুক্ত পোস্টটিতে বর্ণিত ECMAScript রেজেক্সে কিছু সমস্যা সমাধানের মাধ্যমে আমি সুপারিশ করব।

এটি আমার ধারণা ছিল:

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

তারপরে আমি ফ্যাক্টরিয়াল সংখ্যায় মূল কারণগুলির সংখ্যাবৃদ্ধি নিয়ে কিছু গবেষণা করেছি এবং শিখেছি যে এর জন্য একটি সূত্র আছে - এবং এটি সম্ভবত আমি ইসিএমএ রেজেক্সে প্রয়োগ করতে পারি!

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

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

তবে এই অ্যালগরিদমের অসুবিধা এবং দৈর্ঘ্যের কারণে, আমি এটি প্রয়োগ করতে আণবিক lookaheads (ফর্মের (?*...)) ব্যবহার করেছি। এটি ECMAScript বা অন্য কোনও মূলধারার রেজেক্স ইঞ্জিনে নয় এমন একটি বৈশিষ্ট্য, যা আমি আমার ইঞ্জিনে প্রয়োগ করেছি । আণবিক লুকোহেডের অভ্যন্তরে কোনও ক্যাপচার না থাকলে এটি কার্যত একটি পারমাণবিক লুকের সাথে সমান, তবে ক্যাপচারগুলির সাহায্যে এটি খুব শক্তিশালী হতে পারে। ইঞ্জিনটি লুকোহেডে ব্যাকট্র্যাক করবে এবং এটি কোনও মানটি অনুমান করতে ব্যবহার করা যেতে পারে যা ইনপুটটির অক্ষর না খেয়ে সমস্ত সম্ভাবনার (পরবর্তী পরীক্ষার জন্য) চক্রটি আবর্তিত করে। এগুলি ব্যবহার করে অনেক পরিষ্কার বাস্তবায়নের ব্যবস্থা করা যায়। (পরিবর্তনশীল দৈর্ঘ্যের বর্ণনক্ষেত্রটি আণবিক চেহারাগুলির তুলনায় পাওয়ারের তুলনায় খুব কমই সমান, তবে পরবর্তীটি আরও সোজা এবং মার্জিত বাস্তবায়নের দিকে ঝোঁক দেয়))

সুতরাং 733 এবং 690 বাইট দৈর্ঘ্য আসলে সমাধানের ECMAScript- সামঞ্জস্যপূর্ণ অবতারকে উপস্থাপন করে না - সুতরাং তাদের পরে "+"; সেই অ্যালগরিদমকে খাঁটি ইসমাস্ক্রিপ্টে পোর্ট করা সম্ভব (যা এর দৈর্ঘ্যটি খানিকটা বাড়িয়ে তুলবে) তবে আমি এটার কাছাকাছি যাই নি ... কারণ আমি অনেক সহজ এবং আরও কমপ্যাক্ট অ্যালগরিদমের কথা ভেবেছিলাম! এমন একটি যা আণবিক লুক হেডস ছাড়া সহজেই প্রয়োগ করা যেতে পারে। এটি উল্লেখযোগ্যভাবে দ্রুতও।

আগের মতো এই নতুনটিকে অবশ্যই বিপরীতমুখী কৌতূহলের উপর অনুমান করা উচিত, সমস্ত সম্ভাবনার মধ্য দিয়ে সাইকেল চালানো এবং ম্যাচের জন্য তাদের পরীক্ষা করা testing এটি যে কাজটি করতে হবে তার জন্য জায়গা তৈরি করতে N কে 2 দ্বারা বিভক্ত করে এবং তারপরে একটি লুপ বীজ করে যা বারবার 3 দ্বারা শুরু হওয়া বিভাজক এবং প্রতিবার ইনক্রিমেন্টের দ্বারা ইনপুটটি বিভক্ত করবে। (যেমন, 1! এবং 2! মূল অ্যালগরিদমের সাথে মিলে যায় না, এবং পৃথকভাবে মোকাবেলা করতে হবে)) বিভাজকটি চলমান অংশে যুক্ত করে ট্র্যাক রাখা হয়; এই দুটি সংখ্যা নির্বিঘ্নে পৃথক করা যেতে পারে কারণ, এম ধরে নিচ্ছি! == N, চলমান ভাগফল এম দ্বারা বিভাজক হতে থাকবে যতক্ষণ না এটি এম এর সমান হয় until

এই রেজেক্স লুপের অন্তর্নিহিত অংশে বিভাজন-দ্বারা-পরিবর্তনশীল করে। বিভাগের অ্যালগরিদমটি আমার অন্যান্য রেজিক্সের মতো (এবং বহুগুণ অ্যালগরিদমের অনুরূপ): A≤B এর জন্য, A * B = C যদি কেবলমাত্র C% A = 0 এবং B হয় সর্বাধিক সংখ্যা যা B≤C কে সন্তুষ্ট করে এবং সি% বি = 0 এবং (সিবি- (এ-1))% (বি -1) = 0, যেখানে সি লভ্যাংশ, এ বিভাজক, এবং বি ভাগফল হয়। (A≥B এর ক্ষেত্রে একই ধরণের অ্যালগরিদম ব্যবহার করা যেতে পারে, এবং যদি এটিকে বি এর সাথে কীভাবে তুলনা করা হয় তা যদি না জানা থাকে তবে একটি অতিরিক্ত বিভাজন পরীক্ষা যা প্রয়োজন তা সবই প্রয়োজন))

তাই আমি ভালবাসি যে সমস্যাটি আমার গল্ফ-অনুকূলিত ফিবোনাচি রেজেনেক্সের চেয়ে কম জটিলতায়ও কমিয়ে আনতে সক্ষম হয়েছিল , তবে আমি হতাশা সহকারে বলছি যে আমার মাল্টিপ্লেক্সিং-পাওয়ার-অফ-একই-বেস কৌশলটি অন্য সমস্যার জন্য অপেক্ষা করতে হবে এটি আসলে এটি প্রয়োজন, কারণ এটি এক না। এটি আমার 651 বাইটের গুণিত অ্যালগরিদমের গল্প 50 বাইট এক দ্বারা পুনরায় সংশ্লেষ করা হচ্ছে!

সম্পাদনা: গ্রিমির দ্বারা পাওয়া ট্রিকটি ব্যবহার করে আমি 1 বাইট (119 → 118) ছাড়তে সক্ষম হয়েছি যা ভাগফলটি বিভাজকের থেকে বড় বা সমান হওয়ার গ্যারান্টিযুক্ত ক্ষেত্রে এই সংক্ষিপ্ত বিভাগকে আরও সংক্ষিপ্ত করতে পারে।

আর কোনও অ্যাডো না দিয়ে, এখানে রেইজেক্সটি রয়েছে:

সত্য / মিথ্যা সংস্করণ (118 বাইট):

^((x*)x*)(?=\1$)(?=(xxx\2)+$)((?=\2\3*(x(?!\3)xx(x*)))\6(?=\5+$)(?=((x*)(?=\5(\8*$))x)\7*$)x\9(?=x\6\3+$))*\2\3$|^xx?$

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

বিপরীত ফ্যাক্টরিয়াল বা কোনও মিল নেই (124 বাইট):

^(?=((x*)x*)(?=\1$)(?=(xxx\2)+$)((?=\2\3*(x(?!\3)xx(x*)))\6(?=\5+$)(?=((x*)(?=\5(\8*$))x)\7*$)x\9(?=x\6\3+$))*\2\3$)\3|^xx?$

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

ECMAScript +\K (120 বাইট) এ বিপরীত ফ্যাক্টরিয়াল বা কোনও মিল নেই Return

^((x*)x*)(?=\1$)(?=(xxx\2)+$)((?=\2\3*(x(?!\3)xx(x*)))\6(?=\5+$)(?=((x*)(?=\5(\8*$))x)\7*$)x\9(?=x\6\3+$))*\2\K\3$|^xx?$

এবং মন্তব্য সহ মুক্ত-দুরত্ব সংস্করণ:

  ^
  (?=                           # Remove this lookahead and the \3 following it, while
                                # preserving its contents unchanged, to get a 119 byte
                                # regex that only returns match / no-match.
    ((x*)x*)(?=\1$)             # Assert that tail is even; \1 = tail / 2;
                                # \2 = (conjectured N for which tail == N!)-3; tail = \1
    (?=(xxx\2)+$)               # \3 = \2+3 == N; Assert that tail is divisible by \3
    # The loop is seeded: X = \1; I = 3; tail = X + I-3
    (
      (?=\2\3*(x(?!\3)xx(x*)))  # \5 = I; \6 = I-3; Assert that \5 <= \3
      \6                        # tail = X
      (?=\5+$)                  # Assert that tail is divisible by \5
      (?=
        (                       # \7 = tail / \5
          (x*)                  # \8 = \7-1
          (?=\5(\8*$))          # \9 = tool for making tail = \5\8
          x
        )
        \7*$
      )
      x\9                       # Prepare the next iteration of the loop: X = \7; I += 1;
                                # tail = X + I-3
      (?=x\6\3+$)               # Assert that \7 is divisible by \3
    )*
    \2\3$
  )
  \3                            # Return N, the inverse factorial, as a match
|
  ^xx?$                         # Match 1 and 2, which the main algorithm can't handle

এই রেজিেক্সগুলির আমার গল্ফ অপ্টিমাইজেশনের পুরো ইতিহাস গিথুবটিতে রয়েছে:

গৌণিক সংখ্যা মেলানোর জন্য Regex - সংখ্যাধিক্য-তুলনা পদ্ধতি, আণবিক lookahead.txt সঙ্গে
গৌণিক numbers.txt মেলানোর জন্য Regex (এক উপরে দেখানো হয়েছে)

((x*)x*)((x*)+)((x+)+)n=3!\233=0

.NET রেজেক্স ইঞ্জিনটি তার আচরণটি ECMAScript মোডে অনুকরণ করে না এবং এইভাবে 117 বাইট রেজেক্স কাজ করে:

এটি অনলাইন চেষ্টা করুন! (এক্সটেনশিয়াল-স্লোডাউন সংস্করণ,। নেট রিজেক্স ইঞ্জিন + ইসমাস্ক্রিপ্ট এমুলেশন সহ)


14

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

ধনাত্মক পূর্ণসংখ্যা আশা করে। রিটার্নস -1falsy এবং -2truthy জন্য।

f=(n,k=2)=>n>1?f(n/k,k+1):~n

console.log(1,  '-->',f(1))   // Truthy (0! or 1!)
console.log(2,  '-->',f(2))   // Truthy (2!)
console.log(3,  '-->',f(3))   // Falsey
console.log(4,  '-->',f(4))   // Falsey
console.log(5,  '-->',f(5))   // Falsey
console.log(6,  '-->',f(6))   // Truthy (3!)
console.log(7,  '-->',f(7))   // Falsey
console.log(8,  '-->',f(8))   // Falsey
console.log(24, '-->',f(24))  // Truthy (4!)
console.log(120,'-->',f(120)) // Truthy (5!)

দ্রষ্টব্য : এই ফাংশনটি বেশ বড় ইনপুটগুলিকে সমর্থন করে (আপনার এটি পড়া উচিত: 'জেএসের জন্য বেশ বড়')। এটি নিরাপদে 2 53 - 1 অবধি কাজ করা উচিত । এটি এন = 121,645,100,408,831,992 থেকে শুরু করে নিশ্চিত হয়ে ব্যর্থ হবে , এই ইনপুটটি 19-এ পরিণত হবে! = 121,645,100,408,832,000 এর আইইইই -754 এনকোডিংয়ের কারণে। সেখানে পারে আগে অন্যান্য মিথ্যা ইতিবাচক ফল হতে 121.645.100.408.831.991 কারণ rounding ত্রুটি, কিন্তু আমি নিশ্চিত জানি না।


চমৎকার - সত্যিই ~শেষে ব্যবহার মত ।
স্টিভ বেনেট

আপনি কি সম্পাদনা করতে পারেন যাতে আমি অগ্রাহ্য করতে পারি? (আপনি জানেন যে কেন আমি downvoted চান, এটা কারণ আমি এই প্রশ্নের এর অস্বাভাবিক ইনপুট / আউটপুট নিয়ম সম্পর্কে ভুলে গেছি আছে।)
CalculatorFeline

নিবন্ধন করুন
ক্যালকুলেটরফলাইনে

11

পাইথন 3 , 39 38 বাইট

f=lambda n,i=1:n>1and f(n/i,i+1)or n<1

একটি recursive ফাংশন, একটি পূর্ণসংখ্যা গ্রহণ n, ফলে প্রতিনিধিত্বমূলক inversley একটি বুলিয়ান মান ফিরে (truthy: Falsefalsey: True)

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

প্রাথমিক মান সহ বারবার nদ্বারা ভাগ করা হয় i, 1যতক্ষণ না বাকীটি তার চেয়ে কম বা তার সমান হয় 1তবে যদি সেই অবশিষ্টটি কম হয়, তবে 1কেবল ফ্যাকটোরিয়ালগুলি সমান একটি অবশিষ্ট অংশের সাথে শেষ হবে 1এবং <এটি একটি বাইটের চেয়ে ছোট হবে ==


@ ওভস আমাদের দুটি ধারাবাহিক ফলাফলের মধ্যে সীমাবদ্ধ করা হয়েছে। এটি, দুর্ভাগ্যক্রমে, 1সমস্ত ফ্যাক্টরিয়ালগুলির 1জন্য ফিরে আসে যা ব্যতীত এটি ফিরে আসে True
জোনাথন অ্যালান

11

জাভা 8, 46 বাইট

i->{int j=1,c=0;for(;j<i;j*=++c);return j==i;}

এটি রোমান গ্রাফের প্রবেশের উপর ভিত্তি করে আমি এক ডজন বা বাইট ছাড়তে সক্ষম হয়েছি। আমি সেখানে এটি পরামর্শ দিয়েছিলাম তবে আমার মন্তব্য করার মতো খ্যাতি নেই! আমার পরিবর্তিত পরীক্ষার রানার কোড:

import java.util.function.Function;
import java.util.stream.IntStream;

public class IsFactorial {
    public static Function<Integer, Boolean> isFactorial = i->{int j=1,c=0;for(;j<i;j*=++c);return j==i;};
    public static int[] truthyCases = {1,2,6,24,120};
    public static int[] falsyCases = {3,4,5,7,8};
    public static void main(String[] args){
        System.out.println(
            IntStream.of(truthyCases).allMatch(i->isFactorial.apply(i)) &&
            IntStream.of(falsyCases).allMatch(i->!isFactorial.apply(i)));
    }
}

9

রেটিনা , 50 38 বাইট

লুপটি সংক্ষিপ্ত করে এবং এর থেকে মুক্তি পেয়ে @ নীলকে 12 বাইটগুলি ধন্যবাদ সংরক্ষণ করেছে ;

.+
1¶$&$*
+`^(1+)¶(\1)+$
1$1¶$#2$*
¶.$

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

1সত্য এবং 0মিথ্যা জন্য আউটপুট ।

.+ পুরো সংখ্যার সাথে মেলে

1¶$&$*এটির পরিবর্তে 1একটি নতুন লাইন এবং ম্যাচটি অকেরে রূপান্তরিত হয়

অবশিষ্ট প্রোগ্রামটি ধারাবাহিকভাবে ইতিবাচক পূর্ণসংখ্যা বাড়িয়ে, শীর্ষ লাইনে ট্র্যাক করে রেখে, নীচের লাইনে অবিচ্ছিন্ন সংখ্যাটি ভাগ করে দেয় যখন এটি করা সম্ভব হয়।

+` স্ট্রিং একই থাকে না হওয়া পর্যন্ত লুপ

  • ^(1+)¶(\1)+$শীর্ষ লাইন অনেক মেলে 1s এবং এটি একটি একাধিক অনেক 1গুলি বটম লাইন এবং সঙ্গে এটি প্রতিস্থাপন

  • 1$1¶$#2$*উপরের লাইনটি অনেকের 1সাথে আরেকটি 1, এটি শীর্ষ রেখার দ্বারা প্রতিনিধিত্ব করা সংখ্যা 1 দ্বারা বৃদ্ধি করা, তারপরে নূতনরেখা এবং নীচের লাইনে শীর্ষ রেখার ম্যাচের সংখ্যা (অর্থাত্ দ্বিতীয় ক্যাপচারিং গ্রুপের ম্যাচের গণনা) ) অনেকগুলি 1, যা শীর্ষ সংখ্যা দ্বারা নীচের সংখ্যাটি ভাগ করে

একবার এটি আর সম্ভব হয় না,

¶.$এই রেজেক্সের মিলগুলির সংখ্যা দিন, যেমন। 1নীচের লাইনে কোন একক উপস্থিত রয়েছে , যা কেবল তখনই ঘটে যখন সংখ্যাটি একটি কল্পিত হয়


যদি সত্যবাদী / মিথ্যা মানগুলির পরিবর্তে কোনও ক্রাশ / ক্র্যাশ অনুমোদিত হয় তবে আমি 36 34 বাইট পেতে পারি ।

^
1¶
{`.+$
$*
^(1+)¶(\1)+$
1$1¶$#2

এটি একই পদ্ধতির দ্বারা যায় তবে $*তৃতীয় এবং চতুর্থ লাইনের সাথে একত্রিত হয় । তৃতীয় লাইনটি একই লুপের একটি অংশ, লুপগুলিতে বাকী রেখাগুলি যেখানে গ্রুপ করে সেখানে {সংক্ষিপ্ত is ফ্যাক্টরিয়ালগুলি লুপটি ভেঙে প্রোগ্রামটির শেষ হয়, যখন অ-ফ্যাক্টরিয়ালগুলি চিরকালের জন্য লুপটিতে আটকে যায় যতক্ষণ না রেটিনা শেষ প্রতিস্থাপনের ফলে একটি ওভারফ্লো এক্সেকশন ফেলে দেয়, ফলে দশমিকের পরিবর্তে অ্যানারিতে নীচে থাকে এবং লুপটির প্রথম প্রতিস্থাপন হয় replacement দশমিক থেকে নীচের রেখাকে অ্যানারিতে রূপান্তরিত করে, তাই এটি দ্রুত ফুঁড়ে উঠেছে।+((


প্রতিস্থাপনের শেষে 1যখন $*তা বোঝানো হয় সেটিকে সরিয়ে একটি বাইট সংরক্ষণ করুন ।
নিল

আরও ভাল, $*অন্য দুটি লাইনের সাথে একত্রিত করুন ।
নিল


3
আমি অভিভূত হয়েছি যে আপনি শর্তাধীন রেটিনা ক্রাশ করার একটি উপায় খুঁজে পেয়েছেন। :)
মার্টিন এন্ডার

2
আপনি একটি ব্যাখ্যা যোগ করতে পারেন?
ক্যালকুলেটরফলাইন

8

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

L!QO

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

ব্যাখ্যা

L      # range [1 ... input]
 !     # calculate factorial of each
  Q    # compare with input for equality
   O   # sum

1
Lএর ইনপুটটি পপ করায় আপনাকে কী প্রথমে ডুপ্লিকেট করার দরকার হবে না ? এছাড়াও, Å!আপনাকে ইনপুটের চেয়ে কম বা সমান ফ্যাক্টরিয়াল একটি তালিকা দেয়।
নিল এ।

@NeilA। কোনও অপারেশনের জন্য স্ট্যাকের পর্যাপ্ত যুক্তি না থাকলে ভাগ্যক্রমে ইনপুটটি আবার পপ হয় so সুতরাং আমার Dএখানে দরকার নেই। সম্পর্কে ভাল ধরা Å!। আমি সর্বদা তালিকা-আদেশগুলি সম্পর্কে ভুলে যাই। এটি কোনও বাইট সংরক্ষণ করবে না, তবে এটি নিশ্চিত করার জন্য এটি আরও কার্যকর।
এমিগিনা

ইনপুটটি আবার পপ হওয়ার বিষয়ে আমি জানতাম না ... এটি নিশ্চিত যে প্রচুর বাইট সংরক্ষণ করতে পারে।
নিল এ।

@NeilA। এটি মোটামুটি নতুন বৈশিষ্ট্য। এটি এক মাসেরও কম সময় আগে যুক্ত হয়েছিল বলে আমি মনে করি।
এমিগানা

8

সি ++, 102 100 92 বাইট

#include<cmath>
int a(int n){int i=n,j=0;for(;i;)j|=lround(exp(lgamma(i--+1)))==n;return j;}

থেকে সব মান মাধ্যমে loops 0জন্য nএবং গৌণিক এবং তারপর চেক গণনা করে এটা সমান n

ধন্যবাদ ক্রিস্টফ! (8 টি বাইট সংরক্ষিত)


নমস্কার! পিপিসিজিতে আপনাকে স্বাগতম! প্রথম উত্তর! ভবিষ্যতের জন্য সৌভাগ্য কামনা করছি!
অর্জুন

প্রথম উত্তর! আপনি ভালো কিছু বাইট সংরক্ষণ করতে পারেন: int a(int n){int i=n,j=0;for(;i;)j|=lround(exp(lgamma(i--+1)))==n;return j;}lroundএবং lgammaইতিমধ্যে সি ++ 11 তাই কেবল পারা #include<cmath>। হতে পারে আপনি আমার পরামর্শগুলিকে আরও উন্নতি করতে পারেন :)
ক্রিস্টোফ

7

2
f n=elem n$scanl1(*)[1..n]হাস্যকর অদক্ষ তবে খাটো।
লাইকনি

কোড দক্ষতা সম্পর্কে কিছু নিয়ম নেই?
suude

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

"সমাধানটি একটি যুক্তিসঙ্গত সময়সীমার মধ্যেই শেষ হওয়া উচিত" এর ধারায় কিছু বোঝাতে চাইছিলাম তবে আমি অনুমান করি এটি প্রয়োজনীয়তার সাথে কোনওভাবেই ফিট করে। ধন্যবাদ!
sudee

1
সুন্দর এবং সহজ। আমি বিভাজন-Say সঙ্গে আরো ভালো করতে পারে, divModদ্বারা [1..]1 (গৌণিক) এর ভাগফল বা অশূন্য বাকি (অ-গৌণিক) সঙ্গে একটি শূন্য বাকি পৌঁছনো পর্যন্ত ধারাবাহিকভাবে, কিন্তু এটা সঠিক পন্থা হবে বলে মনে হচ্ছে না। আমি এই চতুর 46-অক্ষর সমাধান খুঁজে পেয়েছেন, যদিও: f|let x%n=mod n x==0&&(x+1)%div n x||n==1=(1%)
জন

6

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

m#n=n<2||mod n m<1&&(m+1)#div n m
(2#)

এটি অনলাইন চেষ্টা করুন! উদাহরণ ব্যবহার: (2#) 24। রিটার্ন Trueবা False

এটি এখনও খুব দক্ষ থাকা অবস্থায় আমি পেতে পারি get এমনকি বৃহত্তর হিসাবে সংখ্যার জন্য

145183092028285869634070784086308284983740379224208358846781574688061991349156420080065207861248000000000000000000

ফলাফল অবিলম্বে দেওয়া হয়। সমাধান ইনপুট বিভাজক করে কাজ করে nদ্বারা m = 2,3,4,5,...পর্যন্ত হয় ফলাফলের অন্যতম বা nদ্বারা বিভাজ্য নয় m

খাটো কিন্তু অবিশ্বাস্য অদক্ষ 26-বাইট সমাধান যা নির্ণয় জন্য n!ইনপুট যে তাদের জন্য ফ্যাক্টরিয়ালগুলির চেহারা এখানে



5

ফুরিয়ার , 40 39 বাইট

I~Q1~N(i^~i*N~N{Q}{1~Xo}N>Q{1}{1~X0o}X)

ফোরাইডে চেষ্টা করে দেখুন!

মূলত N সংখ্যাটিকে একটি বাড়ন্ত পরিমাণ দ্বারা গুণিত করে যতক্ষণ না N হয় হয় সমান (আউটপুট 1) বা ইনপুট (আউটপুট 0) এর চেয়ে বড় হয়।

ব্যাখ্যা সিউডোকোড:

Q = Input
N = 1
While X != 1
    i += 1
    N = N*i
    If N = Q Then
        Print 1
        X = 1
    End If
    If N > Q Then
        Print 0
        X = 1
    End If
End While

5

জাপট , 8 6 বাইট

ol x¥U

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

এটি মিথ্যা জন্য 0 এবং সত্য হিসাবে 1 আউটপুট দেয়।

ব্যাখ্যা

 ol x¥ U
Uol x==U
Uo       # Create the range [0 ... input]
  l      # Replace each element by its factorial
     ==U # Compare each element to the input (yielding 1 if equal and 0 otherwise)
    x    # And sum the result

1
আমার সত্যই অন্তর্নির্মিত একটি "অন্তর্ভুক্ত" যুক্ত করা উচিত: পি
ইটিএইচ প্রোডাকশনগুলি

1
ওহে, আপনি পরিবর্তন aU ¦Jকরতে পারেন x¥U(প্রতিটি Xমান X==Uএবং যোগফল), যদিও এটি টিআইওতে কাজ করবে না।
ইটিএইচ প্রোডাকশনগুলি

2Becuase জন্য ব্যর্থতা oকেবল আপনাকে দেবে [0,1]। 1 টি বাইট সাশ্রয় সহ এখানে একটি ফিক্স
শেগি

4

পার্ল 5, 31 বাইট

$a=<>;$a/=++$i while$a>1;exit$a

এসটিডিআইএন এর মাধ্যমে ইনপুট নেওয়া হয়, প্রস্থান কোডের মাধ্যমে আউটপুট দেওয়া হয় (1 টি ফ্যাকটোরিয়াল, 0 অ-ফ্যাক্টরিয়াল জন্য)।

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



4

পার্ল 6 , 29 বাইট

{($_,{$_/++$}...2>*).tail==1}

এটা পরীক্ষা করো

সম্প্রসারিত:

{   # bare block lambda with implicit parameter 「$_」

  (              # generate a sequence

    $_,          # starting with the input

    {
      $_ / ++$   # divide previous element by an ever increasing number
                 # 1,2,3,4,5,6,7,8 ... *
    }

    ...          # keep generating until

    2 > *        # 2 is greater than what was generated
                 # ( 1 or a fractional number )

  ).tail == 1    # check if it ended at 1
}

17 বাইট: {$_∈[\*] 1..$_}। আরেকটি আকর্ষণীয় পদ্ধতির হয় 2>*.polymod(1..*).sum
nwellnhof

4

সেটলএক্স , 32 বাইট

f:=n|=>exists(x in{0..n}|n==x!);

এমন একটি ফাংশন তৈরি করে fযেখানে আপনার প্যারামিটার হিসাবে আপনার সম্ভাব্য ফ্যাক্টরিয়ালটি ব্যবহার করে।

এটি নির্বিচারে পূর্ণসংখ্যার আকারের সাথে কাজ করে তবে এটি মোটামুটি অদক্ষ।

(উপায় দ্বারা: এটি একটি প্রোগ্রামিং ধাঁধাতে আমার প্রথম অংশগ্রহণ)


4

সি (জিসিসি), 33 বাইট

e;f(n){n=n%++e?n==!(e=0):f(n/e);}

মনে রাখবেন যে কিছু লেখক "প্রাকৃতিক সংখ্যা "টিকে ধনাত্মক পূর্ণসংখ্যা হিসাবে সংজ্ঞায়িত করে । অতএব আমি যত্ন করি না যে f(0)একটি অসীম পুনরাবৃত্তি ঘটায়।



32 বাইটে বাদ দেওয়া যায়: এটি অনলাইনে চেষ্টা করুন! অথবা 31 বাইট নোনজারো মিথ্যা বলে ফেরত দিয়ে: এটি অনলাইনে চেষ্টা করুন!
ডেডকোড


4

সি # (.নেট কোর) , 68 বাইট

bool f(System.Numerics.BigInteger n,int k=2)=>n<2||n%k<1&f(n/k,k+1);

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

সংক্ষিপ্ততম সমাধান নয়, তবে সত্যিই বড় সংখ্যার সাথে কাজ করে। টিআইও লিঙ্কটির সাথে একটি উদাহরণ অন্তর্ভুক্ত রয়েছে 10000!

এখানে একটি সংক্ষিপ্ত সংস্করণ যা ব্যবহার করে intযার সর্বাধিক মূল্য 2147483647

সি # (.নেট কোর) , 45 বাইট

bool f(int n,int k=2)=>n<2||n%k<1&f(n/k,k+1);

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

উভয় উত্তর থেকে মোট 3 বাইট গল্ফ করার জন্য @ কেভিন ক্রুজসনে ক্রেডিট!


2
&&থেকে golfed যাবে &, এবং পিছনের ;ল্যামডা কাজকর্মের জন্য গণনা করা হবে নেই। এছাড়াও, আপনার 50-বাইট উত্তরে থাকা ulong k=2যাবে uint k=2না?
কেভিন ক্রুইজসেন

1
&বনাম ভাল ধরা &&। আমি ভেবেছিলাম আমি একটি স্ট্যাক ওভারফ্লো পেয়ে যাচ্ছি, তবে এটি এখন পর্যন্ত কাজ করবে বলে মনে হচ্ছে। 32 ulongটি যখন uint32 বিট হয় It মনে হচ্ছে অন্যরা ব্যবহার করছে intতাই সম্ভবত আমি এটি সংক্ষিপ্ত সংস্করণের জন্য ব্যবহার করব। অনুসরণের ক্ষেত্রে ;, এগুলি লম্পটস নয়, সম্পূর্ণ ফাংশন, তাই আমার মনে হয় এগুলি অন্তর্ভুক্ত করা দরকার?
দানা

এটি সত্যিই আশ্চর্যজনক যে। নেট কীভাবে সমাধান করতে পারে /এবং এর %মধ্যে ulongএবং uint, কিন্তু না ulongএবং int। জানতাম না :)
ডানা

1
@ অলিভার - doubleআপনি কোনও সময়ে গোলাকার দেখতে শুরু করেছেন - উদাহরণস্বরূপ, 24! এবং 120! ব্যর্থ হয়। যদিও System.Numerics.BigIntegerসর্বাধিক নির্ভুলতা রয়েছে, intসংক্ষিপ্ত উত্তরটি হল :)
দানা

1
@ ডেডকোড - আপনার সম্পর্কে 0 ঠিক আছে :) চ্যালেঞ্জের উদাহরণগুলির ভিত্তিতে, আমি "প্রাকৃতিক সংখ্যাগুলি" বোঝাতে 1,2 বোঝাতে চেয়েছি, ... আমি সম্মত হই যে বাস্তব জগতে শর্ট সার্কিট &&অপারেটরটি ব্যবহার করা ভাল is । তবে এটি কোড গল্ফ;) খুশির 10000!উদাহরণটি পছন্দ করেছেন !
দানা

4

সি ++ (ঝনঝন), 51 বাইট

গল্ফিং যতদূর যায় পুনরাবৃত্তি জিততে পারে।

51 বাইট, শূন্য সত্য:

int f(int n,int i=2){return n<2?!n:n%i|f(n/i,i+1);}

এই সঞ্চয়টি বাইট 1 বাইটের জন্য যথেষ্ট গতিতে ত্যাগ করে। প্রতিস্থাপন |সঙ্গে ||লজিক্যাল বা স্বল্প-সার্কিট মূল্যায়ন কারণে ফাস্ট এটি করা,।

এটি অনলাইন চেষ্টা করুন! (51 বাইট ধীর সংস্করণ)
এটি অনলাইনে চেষ্টা করুন! (52 বাইট দ্রুত সংস্করণ)

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

int isFactorial(int n, int i=2)
// returns 0 for true, and nonzero for false
{
    if (n < 2) // same as "if (n==0 || n==1)" in our natural number input domain
    {
        if (n==0)
            return 1; // not factorial
        else // n==1
            return 0; // is factorial (could be either 0! or 1!)
    }

    // Because any nonzero value represents "false", using "|" here is equivalent
    // to "||", provided that the chain of recursion always eventually ends. And
    // it does always end, because whether or not "n" is factorial, the "n / i"
    // repeated division will eventually give the value of zero or one, satisfying
    // the above condition of termination.
    return (n % i) | isFactorial(n / i, i+1);
}

অবহেলিত দ্রুত সংস্করণ:

int isFactorial(int n, int i=2)
// returns 0 for true, and nonzero for false
{
    if (n < 2) // same as "if (n==0 || n==1)" in our natural number input domain
    {
        if (n==0)
            return 1; // not factorial
        else // n==1
            return 0; // is factorial (could be either 0! or 1!)
    }

    if (n % i != 0)
        return 1; // not factorial
    else
        return isFactorial(n / i, i+1);
}

এটি পুনরায় সাজানোর অনেকগুলি উপায় রয়েছে।

52 বাইট, ননজারো সত্য:

int f(int n,int i=2){return n<2?n:n%i?0:f(n/i,i+1);}

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

52 বাইট, শূন্য সত্য:

int f(int n,int i=2){return!n?1:n%i?n-1:f(n/i,i+1);}

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

পুনরাবৃত্তি অবলম্বন করার আগে, আমি কয়েকটি পুনরাবৃত্তি সংস্করণ তৈরি করার চেষ্টা করেছি এবং সেগুলি কাছে এসেছিল।

54 বাইট, ননজারো সত্য:

int f(int n){for(int i=2;n>1;)n=n%i?0:n/i++;return n;}

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

54 বাইট, শূন্য সত্য ( রোমান গ্রাফের জাভা 8 জমা দেওয়ার উপর ভিত্তি করে ):

int f(int n){int a=1,i=0;for(;a<n;a*=++i);return a-n;}

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

এখন, ব্যারেলের নীচের অংশে, কোনও n==0পরিচালনা ছাড়াই পুনরাবৃত্ত সংস্করণগুলি (আমি এগুলিকে অবৈধ মনে করি, কারণ 0 একটি প্রাকৃতিক সংখ্যা, এবং কোনও সংজ্ঞা যেখানে এটি খুব সীমিত ব্যবহারের "প্রাকৃতিক সংখ্যা" নয়)। নীচের সংস্করণগুলিতে, f(0)স্ট্যাকের উপচে পড়া প্রবাহের কারণে, অথবা এটি পুনরাবৃত্তিতে অনুকূলিত করে এমন সংকলকগুলির সাথে সীমাহীন পুনরাবৃত্তিটি সেগফ্ল্টকে ট্রিগার করে: যা অন্তহীনভাবে লুপ করে:

48 বাইট, শূন্য সত্য:

int f(int n,int i=2){return n%i?n-1:f(n/i,i+1);}

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

48 বাইট, শূন্যটি সত্য ( হ্যাগেন ভন ইটজেনের 33 বাইট সি (জিসিসি) জমা দেওয়ার ভিত্তিতে ):

int f(int n,int e=0){return n%++e?n-1:f(n/e,e);}

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


50 সম্পাদনা: 49 , পুনরাবৃত্তি ছাড়াই।
গ্রিমি

48 এর জন্য পুনরাবৃত্তিতে ফিরে যান । এবং আপনি সম্ভবত এটি পছন্দ করবেন না, তবে 44 বৈশ্বিক ভেরর ব্যবহার করে।
গ্রিমি

3

গণিত, 20 বাইট

!FreeQ[Range[#]!,#]&

বড় সংখ্যা পরীক্ষা করার জন্য অন্যান্য সংস্করণ (মন্তব্য দেখুন)

Range[10^3]!~MemberQ~#&

1000 পর্যন্ত পরীক্ষা!


2
আমি যেমন প্রশ্নটি বুঝতে পারি, গণিত যদি 1001 নিতে সক্ষম হয়! ইনপুট হিসাবে এটি পরে এই নকশায় মেলে না।
পিটার টেলর

2
এমনকি সমস্ত ইনপুটগুলির জন্য এটি বৈধ করার সময় আপনি তিনটি বাইট সংরক্ষণ করতে পারেন। # 10 দিয়ে কেবল 10 ^ 3 প্রতিস্থাপন করুন; আপনি রেঞ্জ ব্যবহার করে আরেকটি বাইট সংরক্ষণ করতে পারেন @ #
জুলিয়েন ক্লুজ 20'17

@ জুলিয়ান ক্লুগেন 1243234 অনুসন্ধান করে চিরকালের জন্য নিবে ...
J42161217

1
আমার মনে হয় আপনি প্রতিস্থাপন দ্বারা অন্য বাইট সংরক্ষণ করতে পারবেন Range[#]সঙ্গে Range@#:)
numbermaniac

3
তোমার মত দেখতে রক্ষা করতে পারে এখনো প্রোথিত করা সিনট্যাক্স সাথে অন্য বাইট: !Range@#!~FreeQ~#&
নম্বরমানিয়াক

3

কিউবিক্স , 24 বাইট

U0O@1I1>-?1u>*w;W;@Orq)p

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

Cubified

    U 0
    O @
1 I 1 > - ? 1 u
> * w ; W ; @ O
    r q
    ) p

আমরা স্ট্যাকের উপর চাপ 1, Iএনপুট দিয়ে শুরু করি 1। এগুলি হবে যথাক্রমে আমাদের সূচক, আমাদের লক্ষ্য এবং আমাদের সংযোজক।

আমরা তখন লুপ করি। প্রতিটি পুনরাবৃত্তির সময় আমরা ইনপুট থেকে সংযোজককে বিয়োগ করি। ফলাফলটি যদি 0 হয় তবে আমরা শেষ করেছি, সুতরাং আমরা ধাক্কা 1, Oউতপাদন এবং প্রস্থান করব। যদি এটি নেতিবাচক হয় তবে আমরা অনেক বেশি এগিয়ে চলেছি, সুতরাং আমরা ধাক্কা 0, Oআউটপুট এবং প্রস্থান করব। অন্যথায়, আমরা দেখতে

;p)*rq;
;         Pop the difference off the stack.
 p)       Move the index to the top of the stack and increment it.
   *      Multiply the accumulator by the index to get the next factorial.
    rq;   Put the stack back in the right order.

3

নিম , 8 বাইট

𝐈Γ𝐈𝐩₁𝔼)𝐠

ব্যাখ্যা:

Example input: 6
𝐈         Inclusive range [1 .. input]
          [1, 2, 3, 4, 5, 6]
 Γ        For each...
  𝐈         Inclusive range [1 .. element]
            [[[1], [1, 2], [1, 2, 3], [1, 2, 3, 4], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5, 6]]
   𝐩        Product
            [1, 2, 6, 24, 120, 720]
     𝔼      Check for equality with
    ₁       the first line of input
            [[0, 0, 1, 0, 0, 0]]
      )   End for each
       𝐠  Select largest element
          [1]

চেষ্টা করে দেখুন!

নিম , 3 বাইট (প্রতিদ্বন্দ্বী)

চ্যালেঞ্জটি তৈরি হওয়ার পরে এতে টোকেন এবং ফ্যাকটোরিয়াল টোকেনযুক্ত হিসাবে অ-প্রতিদ্বন্দ্বিতা যুক্ত হয়েছিল।

𝐈𝐓𝕚

ব্যাখ্যা:

Example input: 6
𝐈     Inclusive range [1 .. input]
      [[1, 2, 3, 4, 5, 6]
 𝐓    Factorial each
      [[1, 2, 6, 24, 120, 720]]
  𝕚   Check that the [cycled] input is in the list
      [1]

চেষ্টা করে দেখুন!


3

> <> , 24 22 বাইট

-২ বাইট @ অ্যারনকে ধন্যবাদ

আমি একটি নতুন ভাষা চেষ্টা করছি (যেহেতু আমার গাণিতিক লাইসেন্সটির মেয়াদ শেষ হয়েছে…)

01\{=n;
?!\$1+:@*:{:}(

এটি অনলাইন বা মাছের খেলার মাঠে চেষ্টা করুন

অনুমান ইনপুট সংখ্যা স্ট্যাক ইতিমধ্যে , এবং আয় 0 বা 1. এটা একত্র প্রথম গুন করে কাজ করে এন নম্বর যে স্টপ পর্যন্ত ইনপুট কম হচ্ছে, এবং তারপর মুদ্রণ 1 যদি এটা ইনপুট সমান, এবং 0 যদি এটা doesn ' টি।


আপনি আপনাকে রূপান্তর করতে v>\n<^পারে \\n/; এখানে দেখুন
হারুন

অ্যারন, উজ্জ্বল, আপনাকে ধন্যবাদ!
গাছ নয়

3

এপিএল (ডায়ালগ ইউনিকোড) , 5 6 7 বাইট

পরিবর্তন করে একটি বাইট Golfed ×/করার !এরিক Outgolfer ধন্যবাদ

⊢∊!∘⍳

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

ব্যাখ্যা

                          Range of numbers from 1 to argument, 1 2 3 4 .. n
   !                       Factorial; 1! 2! 3! 4! .. n!
⊢∊                         Is the right argument a member of this list?

সমষ্টিগত যোগফল?
ফাঁস নুন

@ লিকিউন ফিক্সড
ক্রিটসি লিথোস 20'17

জিএনইউ এপিএল ১.২ এর একটি অতিরিক্ত বাইট N∊×\⍳N←⎕কীভাবে এটি একটি যুক্তি লাগে? আমি nকোথাও দেখতে পাচ্ছি না। এটি কি ডায়ালগ-নির্দিষ্ট জিনিস?
আর্ক 676

2
@ আর্ক 6766 আমার সমাধানটি একটি ট্রেন এবং আপনি এটির মতো কল করেছেন: (⊢∊(×/⍳)) right_argumentআপনি টিআইও লিঙ্কে দেখতে পাচ্ছেন। এবং সঠিক যুক্তি বোঝায়।
কৃতিক্সী লিথোস

দ্রষ্টব্য: এজিএল আপনাকে একটি বাইট বাঁচাবে; ⊢∊×\ä⍳। "সঠিক" (তবে দীর্ঘ) সমাধানটি হবে 0=1|!⍣¯1; "বিপরীতমুখীটি কি পূর্ণসংখ্যা হয়?"
অ্যাডম

2

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

এটি ইনপুটটিকে ফাংশন আর্গুমেন্ট এবং alertআউটপুট হিসাবে গ্রহণ করে। 0মিথ্যা এবং সত্যের ফলাফল 1

f=n=>n?n*f(n-1):1;g=(n,r=0,i=0)=>{while(i<=n){r=f(i)==n|r;i++}alert(r)}

ব্যাখ্যা

প্রোগ্রাম দুটি ফাংশন নিয়ে গঠিত, fএবং gfএটি একটি পুনরাবৃত্ত ফ্যাক্টরিয়াল-কম্পিউটিং ফাংশন এবং gএটি প্রোগ্রামটির মূল কাজ। একক যুক্তি g ধরে নিয়েছে n। এটি r0 এর মান সহ একটি ডিফল্ট আর্গুমেন্ট এবং এর মান সহ অন্য একটি ডিফল্ট তর্ক যুক্ত করে 0। এটা তোলে, তারপর, 0 থেকে সব পূর্ণসংখ্যার উপর iterates n, এবং, প্রতিটি পুনরাবৃত্তির, ফাংশন কিনা তা পরীক্ষা fউপর প্রয়োগ i(বর্তমান INDEX) সমান n, অর্থাৎ কিনা nএকটি গৌণিক হয় i। যে ক্ষেত্রে হতে হয়, তা হলে rএর মান ফাংশন শেষে 1. সেট করা থাকে, rহয় alerted।

পরীক্ষার স্নিপেট

( নোট: ব্যবহার স্নিপেট আউটপুট console.log()যারা বিরক্তিকর অনেক কেউ পছন্দ করে না যেমন alert()সে। )

f=n=>n?n*f(n-1):1;g=(n,r=0,i=0)=>{while(i<=n){r=f(i)==n|r;i++}console.log(r)}

g(1)
g(2)
g(3)
g(4)
g(5)
g(6)
g(7)
g(8)
g(24)
g(120)


কোড ব্লক ব্যবহারের চেয়ে ইভালটি আরও কম হতে পারে।
ডাউনগোট

@ ডাউনগোট আমার কীভাবে এটি করা উচিত? দুঃখিত যদি এটি খুব সুস্পষ্ট হয়! : পি
অর্জুন

2

কিউবিআইসি , 21 19 বাইট

[:|q=q*a~q=b|_x1}?0

ব্যাখ্যা

[:|     Start a FOR loop from 1 to n
q=q*a   q starts as 1 and is multiplied by the FOR loop counter
        consecutively: q=1*1, *2, *3, *4 ... *n
~q=b|   If that product equals n
_x1     Then quit, printing a 1
}       Close the IF and the FOR
?0      If we're here, we didn't quit early and didn't find a factorial, print 0

পূর্বে

[:|q=q*a┘c=c+(q=b)}?c

ব্যাখ্যা:

[:|         Start a FOR loop from 1 to n
q=q*a       q starts as 1 and is multiplied by the FOR loop counter
            consecutively: q=1*1, *2, *3, *4 ... *n
┘           Syntactic line break
c=c+        c starts out at 0 and then keeps track of 
    (q=b)       how often our running total == n
}           Closes the FOR-loop
?c          Print c, which is 0 fir non-factorials and -1 otherwise.

2

জাভা 8, 59 বাইট

i->{for(int j=1,c=0;j<=i;j*=++c)if(j==i)return 1;return 0;}

Testcode

import java.util.function.IntFunction;
import java.util.stream.IntStream;

public class IsFactorial
{
    public static IntFunction<Integer> isFactorial = i->
    {
        for(int j=1,c=0;j<=i;j*=++c)
            if(j==i)return 1;return 0;
    };

    public static int[] truthyCases = {1,2,6,24,120};
    public static int[] falsyCases = {3,4,5,7,8};

    public static void main(String[] args)
    {
        System.out.println
        (
            IntStream.of(truthyCases)
                .allMatch(i->isFactorial.apply(i)==1)
            && IntStream.of(falsyCases)
                .allMatch(i->isFactorial.apply(i)==0)
        );
    }
}
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.