নম্বরটি যদি একটি ব্যাপ্তির মধ্যে থাকে তবে কীভাবে মার্জিতভাবে যাচাই করবেন?

157

সি # এবং .NET 3.5 / 4 দিয়ে আমি কীভাবে মার্জিতভাবে এটি করতে পারি?

উদাহরণস্বরূপ, একটি সংখ্যা 1 এবং 100 এর মধ্যে হতে পারে।

আমি যথেষ্ট জানি যদি একটি সহজ; কিন্তু এই প্রশ্নের মূল শব্দটি কমনীয়তা। এটি আমার খেলনা প্রকল্পের জন্য নয় উত্পাদনের জন্য।

এই প্রশ্নগুলি গতি সম্পর্কে নয়, কোড সৌন্দর্যের বিষয়ে। দক্ষতা এবং যেমন সম্পর্কে কথা বলা বন্ধ করুন; মনে রাখবেন আপনি গায়কদের কাছে প্রচার করছেন

c#  numbers  int 
— সার্জিও তাপিয়া
সূত্র
23
উত্তর: আপনার "সম্পাদনা" - সহজ মার্জিত । আমি ব্যক্তিগতভাবে এই চেকটি করার কোনও অ-মানক উপায়ের চেয়ে যদি বিবৃতিটি আরও মার্জিত বলে মনে করি ...
— রিড কোপসি
4
"সবকিছু যতটা সম্ভব সহজ করা উচিত, তবে সহজ নয়" " - অ্যালবার্ট আইনস্টাইন
— কর্সিকা
3
@ সার্জিও: আমার মনে হয় না আমি পেডেন্টিক হচ্ছি। আমি মনে করি যে লোকেরা ইতিমধ্যে সহজ জিনিসগুলিকে প্রতিস্থাপনের জন্য ভাষায় প্রায়শই এক্সটেনশন পদ্ধতি এবং অন্যান্য সরঞ্জামগুলিকে অপব্যবহার করে। দুটি অন্তর্নিহিত মানগুলির তুলনা করার জন্য শত শত উপায় রয়েছে, তবে আরও স্পষ্টতই কিছু ব্যবহার করা একটি দুর্বল পছন্দ, আইএমও।
— রিড কোপসি
3
@ সেরজিও: আমার ধারণা, তখন, আমি প্রশ্নের বিন্দুটি দেখতে পাই না;)
— রিড কোপসি
6
@ সার্জিও: যদি if"বারোক" না হয় তবে এটি ঠিক করবেন না।
— স্ট্রিপলিং ওয়ারিয়র

উত্তর:

154

অনেকগুলি বিকল্প রয়েছে:

int x = 30;
if (Enumerable.Range(1,100).Contains(x))
    //true

if (x >= 1 && x <= 100)
    //true

এছাড়াও, রেজেক্স বিকল্পগুলির জন্য এই এসও পোস্টটি দেখুন ।

— ডাস্টিন লাইন
সূত্র
334
পরিগণিত.রেঞ্জকে প্রথমে সংখ্যাগুণের সংখ্যা তৈরি করতে হবে এবং তারপরে প্রতিটি আইটেমটি লুপ করতে হবে। মানটি পরীক্ষা করার তুলনায় এটি একটি ভয়ানক ধারণা এবং কার্য সম্পাদন যা একেবারেই আলাদা। আমি মনে করি আমাদের একটি মোটো গ্রহণ করা উচিত, কেবল লিনকিউ এক্সটেনশানগুলি দুর্দান্ত, এর অর্থ এই নয় যে এগুলি সবকিছুর জন্য ব্যবহার করা উচিত।
— ম্যাথিউ অ্যাবট
14
— অ্যাডাম রবিনসন
15
আমি সম্মতি জানাই এটি একটি ভয়ংকর ধারণা পারফরম্যান্স ভিত্তিক, তবে ওপি ifবিবৃতি চেয়ে আরও অভিনব কিছু চায় । এটি অবশ্যই এটি সম্পাদন করে ...;)
— টিম কোকার
10
এটি লক্ষণীয় যে দ্বিতীয় প্যারামিটারটি "স্টপ" নয়, "গণনা"। উদাহরণস্বরূপ, এনিউমারেবল R রেঞ্জ (150, 300) ont কন্টেন্টস (400) সত্য ফিরে আসবে।
— শথুর
5
দয়া করে এই উত্তরটি ব্যবহার করবেন না । আপনার রেঞ্জগুলি বেশ বড় হলে এটির ভয়াবহ কর্মক্ষমতা থাকবে। দয়া করে উত্তরটি @ অলিভিয়ের-জ্যাকোট-ডেসকোম্বেসের মাধ্যমে দেখুন
— অ্যারন হুডন
95

তুমি বোঝাতে চাচ্ছ?

if(number >= 1 && number <= 100)

অথবা 

bool TestRange (int numberToCheck, int bottom, int top)
{
  return (numberToCheck >= bottom && numberToCheck <= top);
}
— kemiller2002
সূত্র
1
আপনার "সেখানে" দরকার নেই ... এটি সংকলন করবে না। (অন্যথায়, আমি 100% সম্মত)
— রিড কোপসি
4
— @ বেন,
আমি মনে করি এটি সর্বাধিক সলিউড সমাধান তবে প্রশ্নকর্তা যে অনুসন্ধান করছেন তা নয়, তাই না?
— কেভিন সরল
কেবলমাত্র আমি পরিবর্তন করব তা হল পদ্ধতিটিতে স্থির কীওয়ার্ড যুক্ত করা। ;-)
— রবার্ট এস
<বনাম <= এর জন্য অনুমতি দেওয়ার জন্য সীমানা পতাকাগুলির প্রয়োজন, অর্থাত্ ইনরেঞ্জ (সংখ্যা, লোয়ারবাউন্ড, LOWER_IS_INCLUSIVE, আপারবাউন্ড, UPPER_IS_EXCLUSIVE)। আমি এই ছদ্মবেশী হওয়ার ইচ্ছাটি লিখেছিলাম তবে এখন আমি এটির বিষয়ে চিন্তা করি তবে পতাকাগুলি আসলে কলারকে তাদের স্পেসিফিকেশন সোজা পেতে উত্সাহিত করবে।
— উইলিয়াম টি ম্যালার্ড
56

এখানে কেবল আওয়াজ যোগ করতে আপনি একটি এক্সটেনশন পদ্ধতি তৈরি করতে পারেন:

public static bool IsWithin(this int value, int minimum, int maximum)
{
    return value >= minimum && value <= maximum;
}

যা আপনাকে এমন কিছু করতে দেয় ...

int val = 15;

bool foo = val.IsWithin(5,20);

যা বলা হচ্ছে, যখন চেক নিজেই কেবল একটি লাইন থাকে তখন এটি করার মতো নির্বোধ জিনিস মনে হয়।

— অ্যাডাম রবিনসন
সূত্র
1
@ বেন: আমি এই বিষয়টিতে গিয়েছিলাম, যা বলেছে "একটি পরিসরের মধ্যে" (যা আমি মনে করি না যে এই বিষয়ে অস্পষ্ট) তবে আপনি ঠিক বলেছেন যে প্রশ্নবঙ্গটি "1 থেকে 100 এর মধ্যে" বলেছে (যা , অবশ্যই, অস্পষ্ট)।
— অ্যাডাম রবিনসন
48

যেমনটি অন্যরা বলেছেন, একটি সাধারণ ব্যবহার করুন যদি।

অর্ডার সম্পর্কে আপনার ভাবা উচিত।

যেমন

1 <= x && x <= 100

চেয়ে পড়া সহজ

x >= 1 && x <= 100
— এসবেন স্কভ পেদারসেন
সূত্র
19
"ইজিজার" দর্শকের চোখে পড়ে। আমি ব্যক্তিগতভাবে বামদিকে প্রশ্নে পরিবর্তনশীল থাকতে পছন্দ করি এবং ডানদিকে প্রশ্নে না ধ্রুবক বা পরিবর্তনশীল থাকতে পারি ।
— অ্যাডাম রবিনসন
15
ইন পার্ল 6 , আপনি লিখতে হবে 1 <= x <= 100।
— জর্দো
2
নম্বর লাইন অর্ডার প্রাথমিকভাবে পরিষ্কার - তবে আপনি অন্য আদেশগুলির জন্য নিজের চোখ / মনকে প্রশিক্ষণ দিতে পারেন। বিশেষত - আমি সর্বদা বামদিকে ধ্রুবক স্থাপনের কৌশলটি পছন্দ করি । আপনি যদি এটি করেন তবে সংকলক আপনাকে যখন টাইপের =পরিবর্তে টাইপ করবে তখন আপনাকে বলবে ==। এটি অ-সাম্যতা সম্পর্কিত অপারেটরগুলির সাথে সহায়তা করে না - তবে এটি ধারাবাহিকভাবে ব্যবহার করতে অভ্যস্ত হওয়া সহজ।
— ডেভিডবাক
1
আমি কেবল যুক্ত করতে চাই যে এই সমাধানটি কোনও ক্ষেত্রেই কার্যকর নয়। বিবেচনা xকরা একটি জটিল ফাংশন কল বা সময়সাপেক্ষ লিনক-এক্সপ্রেশন। এক্ষেত্রে আপনি এটি দু'বার করবেন যা কোনও ভাল জিনিস নয়। নিশ্চয়ই আপনার মানটি একটি অস্থায়ী স্থানীয় পরিবর্তনশীল হিসাবে সংরক্ষণ করা উচিত তবে কয়েকটি ক্ষেত্রে রয়েছে (যেমন- অন্যথায়- if- বিবৃতি) যেখানে আপনি কেবল অন্যের পরে যদি ফাংশনগুলি কল করতে চান বা অন্যথায়-যদি ব্যর্থ হয়। অস্থায়ী ভেরিয়েবলগুলির সাথে আপনাকে সেগুলি আগে যেকোনভাবে কল করতে হবে। এই ক্ষেত্রে একটি এক্সটেনশন পদ্ধতি (অন্যান্য উত্তরে উল্লিখিত) হ'ল সেরা সমাধান ইমো।
— রবার্ট এস
4
আমি নম্বর লাইনের ক্রমটিও পছন্দ করি এবং পরিপূরক পরীক্ষার জন্যও, যেমন x <10 || 20 <এক্স। আমার কাছে এটি চিৎকার করে তোলে "x 10 - 20 এর বাইরে নয়"।
— উইলিয়াম টি। ম্যালার্ড
44

প্রোডাকশন কোড আমি সহজভাবে লিখতে হবে

1 <= x && x <= 100

এটি বোঝা সহজ এবং খুব পঠনযোগ্য।

এখানে একটি চতুর পদ্ধতি যা কিছু গণিত ব্যবহার করে তুলনা সংখ্যা দুটি থেকে এক-এ হ্রাস করে। ধারণাটি এই যে দুটি সংখ্যাগুলির মধ্যে একটি নেতিবাচক হয়ে ওঠে যদি সংখ্যাটি সীমার বাইরে থাকে এবং শূন্যের সংখ্যাটি যদি একটি সীমানার সমান হয়:

সীমাগুলি অন্তর্ভুক্ত থাকলে:

(x - 1) * (100 - x) >= 0

অথবা

(x - min) * (max - x) >= 0

সীমা যদি একচেটিয়া হয়:

(x - 1) * (100 - x) > 0

অথবা

(x - min) * (max - x) > 0
— অলিভিয়ার জ্যাকট-ডেসকোম্বেস
সূত্র
3
আমার মানদণ্ডের দ্বারা এটি এখন পর্যন্ত সবচেয়ে মার্জিত সমাধান, আকর্ষণীয় এটি আমার কাছে এটি উভয় এক্সপ্রেশন দুটি যাচাই করার চেয়েও কিছুটা দ্রুত চলবে বলে মনে হয়েছে, এটি বলেছে এটি আরও বেমানান বলে মনে হচ্ছে (গতি আরও বেশি আলাদা বলে মনে হচ্ছে) দেখতে আকর্ষণীয় হবে যদি কোন গবেষণা করা হয় যার উপর দ্রুততম কোনটি হয়।
— টমাস লিন্ডভাল
3
জাভাস্ক্রিপ্টে আপনার সমাধানটি পরীক্ষা করেছে এবং 14 ডেসিমাল পর্যন্ত ভাসমান-পয়েন্ট সংখ্যার সাথে এর সঠিক। এটি একটি খুব ভাল কোড স্নিপেট। আমি যদি এটি করতে পারি তবে এটি আপনাকে তিনবার উপস্থাপন করতে চাই
— রুব্বিরবার্বার
4
যদিও, একটি বৃহত্তর ইতিবাচক সংখ্যা জড়িত একটি ছোটখাটো সমস্যা আছে, এটি উপচে পড়তে পারে! এক্সডি আপনার কোডটি লেখার সময় এটি মনে রাখতে পারেন might
— BrainStorm.exe
2
প্রশ্নটি কমনীয়তার জন্য জিজ্ঞাসা করে এবং তাই ব্যবহারিক মানের চেয়ে শিক্ষামূলক বেশি। ব্যক্তিগতভাবে আমি কেবল 1 < x && x < 100উত্পাদনশীল কোডে একটি সাধারণ ব্যবহার করব । এটি বুঝতে সহজ।
— অলিভিয়ার জ্যাকট-ডেস্কোম্বেস
1
পারফরম্যান্স সম্পর্কে উদ্বিগ্নদের জন্য, 1 < x & x < 100(কোনও && শর্ট সার্কিট) সংকলককে নির্দেশ দেয় যে এটি সর্বদা মূল্যায়ন করতে পারে x < 100ফলাফল নির্বিশেষে 1 < x। আশ্চর্যজনকভাবে (শাখার পূর্বাভাসের কারণে) কখনও কখনও এড়াতে না যাওয়ার চেয়ে সর্বদা এই সাধারণ অপারেশনটি করা দ্রুত হয়।
— টম লিজ
23

আমি এটি প্রস্তাব:

public static bool IsWithin<T>(this T value, T minimum, T maximum) where T : IComparable<T> {
    if (value.CompareTo(minimum) < 0)
       return false;
    if (value.CompareTo(maximum) > 0)
       return false;
    return true;
}

উদাহরণ:

45.IsWithin(32, 89)
true
87.2.IsWithin(87.1, 87.15)
false
87.2.IsWithin(87.1, 87.25)
true

এবং অবশ্যই ভেরিয়েবল সহ:

myvalue.IsWithin(min, max)

এটি সহজে পড়া (মানব ভাষার কাছাকাছি) এবং যে কোনও তুলনামূলক প্রকার (পূর্ণসংখ্যা, ডাবল, কাস্টম ধরণের ...) এর সাথে কাজ করে।

কোড পড়তে সহজ হওয়া গুরুত্বপূর্ণ কারণ বিকাশকারী এটি বুঝতে "ব্রেইন সাইকেল" নষ্ট করবেন না। দীর্ঘ কোডিং সেশনে নষ্ট মস্তিষ্কের চক্র বিকাশকারীকে আগে ক্লান্ত করে তোলে এবং বাগ প্রবণ করে তোলে।

— আন্তন এম
সূত্র
3
আমি এর মধ্যে শব্দটি ব্যবহার করে এবং অন্তর্ভুক্ত কিনা তা নির্ধারণের জন্য বুলিয়ান পতাকা রেখে আরও সহজ করে দেব
— বেন
ভাল. এটা বোঝা সহজ। আমি IsInRange. I'm not that keen on Ben's inclusive boolean as that requires a few more brain cycles. It has the advantage that it can be used in any class that that implements IComparer. This is in my Extensions now along with লাইস উইথিন / LiesInside. Just can't decide which. নোটআউটসাইড নামটি পরিবর্তন করেছিলাম তবে আমি নেতিবাচক শর্ত পছন্দ করি না
— পলাস্ট্রিয়াস
21

কিছুটা এক্সটেনশন পদ্ধতির অপব্যবহারের সাথে, আমরা নিম্নলিখিত "মার্জিত" সমাধান পেতে পারি:

using System;

namespace Elegant {
    public class Range {
        public int Lower { get; set; }
        public int Upper { get; set; }
    }

    public static class Ext {
        public static Range To(this int lower, int upper) {
            return new Range { Lower = lower, Upper = upper };
        }

        public static bool In(this int n, Range r) {
            return n >= r.Lower && n <= r.Upper;
        }
    }

    class Program {
        static void Main() {
            int x = 55;
            if (x.In(1.To(100)))
                Console.WriteLine("it's in range! elegantly!");
        }
    }
}
— Ferruccio
সূত্র
সমাধান মত! BTW সমেত সমর্থন করার জন্য, তৈরি enum Inclusiveমান: Lower, Upper, All। আর এর জন্য পাস Inধরনের ফাংশন একটি অতিরিক্ত প্যারামিটার enum Inclusiveডিফল্ট মান সঙ্গে Inclusive.Allআপডেট Toহ্যান্ডেল করতে ফাংশন বডির All, Lower, Upperমান :)
— নিকিতা
7

এটি যদি ঘটনাগত ifহয় তবে আপনার যা প্রয়োজন তা সরল । যদি এটি অনেক জায়গায় ঘটে থাকে তবে আপনি এই দুটি বিবেচনা করতে পারেন:

  • PostSharp । সংকলনের পরে পদ্ধতিতে কোডটি 'ইনজেক্ট' করে এমন বৈশিষ্ট্যগুলি সহ পদ্ধতিগুলি সাজান। আমি নিশ্চিতভাবে জানি না, তবে আমি এটি কল্পনা করতে পারি এটি এর জন্য ব্যবহার করা যেতে পারে।

কিছুটা এইরকম:

[Between("parameter", 0, 100)]
public void Foo(int parameter)
{
}
  • কোড চুক্তি । আপনার কোডটির স্থায়ী যাচাইকরণ এবং আপনার কোড ব্যবহারের জায়গাগুলি সংকলনের সময় সীমাবদ্ধতাগুলি পরীক্ষা করা যেতে পারে তার সুবিধা রয়েছে।
— JulianR
সূত্র
কোড চুক্তিগুলির জন্য +1; এটি একটি পরামিতি যাচাই করার জন্য সুনির্দিষ্ট, তবে এটি ঘন ঘন ব্যবহারের কেস এবং স্থির যাচাইকরণের অত্যন্ত কার্যকর হওয়ার সম্ভাবনা রয়েছে।
— ড্যান ব্রায়ান্ট
5

&&দুটি তুলনাতে যোগদানের জন্য একটি এক্সপ্রেশন ব্যবহার করা এটি করার সবচেয়ে সহজ উপায়। যদি আপনি অভিনব এক্সটেনশন পদ্ধতি এবং এগুলি ব্যবহার করার চেষ্টা করেন তবে আপনি উপরের বাউন্ড, নিম্ন বাউন্ড বা উভয়কে অন্তর্ভুক্ত করবেন কিনা এই প্রশ্নে চলে। একবার অন্তর্ভুক্ত রয়েছে তা নির্দেশ করার জন্য আপনি অতিরিক্ত ভেরিয়েবল যুক্ত করা বা এক্সটেনশনের নামগুলি পরিবর্তন করা শুরু করার পরে, আপনার কোডটি পড়তে আরও দীর্ঘতর এবং শক্ত হয়ে যায় (প্রোগ্রামারের বিশাল সংখ্যাগরিষ্ঠদের জন্য)। তদুপরি, পুনরায় ভাগ করার মতো সরঞ্জামগুলি আপনাকে সতর্ক করবে যদি আপনার তুলনাটি বুদ্ধিমান হয় না (number > 100 && number < 1 )) না বোঝে তবে আপনি যদি কোনও পদ্ধতি ব্যবহার না করেন তবে তারা তা করবে না ('i.IsBetween (100, 1)')।

কেবলমাত্র অন্য একটি মন্তব্য আমি করব তা হ'ল যদি আপনি কোনও ব্যতিক্রম ছোঁড়ার অভিপ্রায় সাথে ইনপুটগুলি পরীক্ষা করে থাকেন তবে আপনার কোড চুক্তিগুলি ব্যবহারের বিষয়টি বিবেচনা করা উচিত:

Contract.Requires(number > 1 && number < 100)

এটি এর চেয়ে আরও মার্জিত if(...) throw new Exception(...)এবং আপনি যদি সংখ্যার সীমাটি প্রথমে সীমান্তে না থাকে তা নিশ্চিত না করে যদি কেউ আপনার পদ্ধতিতে কল করার চেষ্টা করে তবে আপনি সংকলন-সময় সতর্কতা পেতে পারেন।

— StriplingWarrior
সূত্র
2
এফওয়াইআই, চুক্তিগুলি স্থির বিশ্লেষককে আরও সুখী করা হয় যখন নিম্ন সীমা এবং উপরের সীমানা সীমাবদ্ধিকে পৃথক পৃথক করে ভাগ করা হয়।
— ড্যান ব্রায়ান্ট
ধন্যবাদ ড্যান ব্রায়ান্ট, আমি এখানে যা খুঁজছিলাম ঠিক সেটাই হ'ল। প্রয়োজনীয়তা এবং অন্যান্য সম্পর্কিত কোড চুক্তি পদ্ধতিগুলির শর্তাবলীর বিষয়ে পরামর্শের জন্য খুব বেশি উপাদান খুঁজে পাওয়া যায় না।
— jpierson
2

আপনি যদি সাধারণের চেয়ে বেশি কোড লিখতে চান তবে, আপনি পারেন: ইসবেটুইন নামে একটি এক্সটেনশন পদ্ধতি তৈরি করুন

public static class NumberExtensionMethods
{
    public static bool IsBetween(this long value, long Min, long Max)
    {
        // return (value >= Min && value <= Max);
        if (value >= Min && value <= Max) return true;
        else return false;
    }
}

...

// Checks if this number is between 1 and 100.
long MyNumber = 99;
MessageBox.Show(MyNumber.IsBetween(1, 100).ToString());

সংযোজন:এটি লক্ষণীয় যে অনুশীলনে আপনি খুব কমই একটি কোডবেসে "সাম্যতার জন্য পরীক্ষা করুন" (বা <,>)। (সবচেয়ে তুচ্ছ পরিস্থিতি ব্যতীত। মনে রাখবেন যে এই উদাহরণে এটি (এমনটি ঘটে) কোনও ফাংশন (ম্যাথএফ.প্রোসোরিওস) ব্যবহার করে যা সেই পরিবেশে নির্মিত; বাস্তবে আপনাকে প্রকৃত সংখ্যার কম্পিউটার উপস্থাপনের জন্য তুলনা বলতে কী বোঝায় সে সম্পর্কে আপনার নিজস্ব ধারণাগুলি যত্ন সহকারে বিকাশ করতে হবে, আপনি যে পরিস্থিতিতে কীভাবে প্রকৌশল করছেন for (এমনকি এটি উল্লেখও করবেন না যে আপনি যদি এমন কিছু করছেন, সম্ভবত কোনও নিয়ামক, পিআইডি নিয়ন্ত্রক বা এর মতো, পুরো বিষয়টি কেন্দ্রিয় এবং খুব কঠিন হয়ে পড়ে, তবে এটি প্রকল্পের প্রকৃতি হয়ে ওঠে।

private bool FloatLessThan(float a, float b)
    {
    if ( Mathf.Approximately(a,b) ) return false;
    if (a<b) return true;
    return false;
    }

private bool FloatLessThanZero(float a)
    {
    if ( Mathf.Approximately(a,0f) ) return false;
    if (a<0f) return true;
    return false;
    }

private bool FloatLessThanOrEqualToZero(float a)
    {
    if ( Mathf.Approximately(a,0f) ) return true;
    if (a<0f) return true;
    return false;
    }
— টনি
সূত্র
1
যদি এবং অন্যটি দিয়ে প্রতিস্থাপন করুনreturn (value >= Min && value <= Max);
— এয়ারক্স
তুলনাটি লেখার মার্জিত উপায়টি হ'ল "লজিকাল ক্রমে ..." যদি (ন্যূনতম <= মান && মান <= সর্বোচ্চ) হয়। এটা অনেক সুন্দর।
— ফ্যাটি
2
এই প্রশ্নে আরও অবাক করা বিষয়, কোনও বাস্তব-বিশ্ব প্রকল্পে কেন্দ্রীয় সমস্যাটির কথা কেউ উল্লেখ করেনি (বিশেষত আপনি যদি গেম ইঞ্জিনিয়ার হন) তবে আপনাকে আনুমানিক সমস্যাটি মোকাবেলা করতে হবে । যে কোনও বাস্তব-বিশ্বের সফ্টওয়্যারগুলিতে আপনি নিজের অবস্থার উপর নির্ভর করে ত্রুটি ইস্যুটি বিবেচনা এবং মোকাবেলা করতে হবে না (সমতা বা <,> যাই হোক না কেন) মূলত কখনই "তুলনা করবেন না"। আমি এই উত্তরের একটি সংযোজন সম্পাদনা করেছি (এখানে একমাত্র সঠিক উত্তর!) যেহেতু আর কোনও উত্তর মঞ্জুরিপ্রাপ্ত নয়।
— ফ্যাটি
এই পর্যবেক্ষণ এবং সংযোজনের জন্য আপনাকে ধন্যবাদ।
— টনি
2

অন্য সমস্ত উত্তর আমার দ্বারা উদ্ভাবিত হয় না, এখানে কেবল আমার বাস্তবায়ন:

public enum Range
{
    /// <summary>
    /// A range that contains all values greater than start and less than end.
    /// </summary>
    Open,
    /// <summary>
    /// A range that contains all values greater than or equal to start and less than or equal to end.
    /// </summary>
    Closed,
    /// <summary>
    /// A range that contains all values greater than or equal to start and less than end.
    /// </summary>
    OpenClosed,
    /// <summary>
    /// A range that contains all values greater than start and less than or equal to end.
    /// </summary>
    ClosedOpen
}

public static class RangeExtensions
{
    /// <summary>
    /// Checks if a value is within a range that contains all values greater than start and less than or equal to end.
    /// </summary>
    /// <param name="value">The value that should be checked.</param>
    /// <param name="start">The first value of the range to be checked.</param>
    /// <param name="end">The last value of the range to be checked.</param>
    /// <returns><c>True</c> if the value is greater than start and less than or equal to end, otherwise <c>false</c>.</returns>
    public static bool IsWithin<T>(this T value, T start, T end) where T : IComparable<T>
    {
        return IsWithin(value, start, end, Range.ClosedOpen);
    }

    /// <summary>
    /// Checks if a value is within the given range.
    /// </summary>
    /// <param name="value">The value that should be checked.</param>
    /// <param name="start">The first value of the range to be checked.</param>
    /// <param name="end">The last value of the range to be checked.</param>
    /// <param name="range">The kind of range that should be checked. Depending on the given kind of range the start end end value are either inclusive or exclusive.</param>
    /// <returns><c>True</c> if the value is within the given range, otherwise <c>false</c>.</returns>
    public static bool IsWithin<T>(this T value, T start, T end, Range range) where T : IComparable<T>
    {
        if (value == null)
            throw new ArgumentNullException(nameof(value));

        if (start == null)
            throw new ArgumentNullException(nameof(start));

        if (end == null)
            throw new ArgumentNullException(nameof(end));

        switch (range)
        {
            case Range.Open:
                return value.CompareTo(start) > 0
                       && value.CompareTo(end) < 0;
            case Range.Closed:
                return value.CompareTo(start) >= 0
                       && value.CompareTo(end) <= 0;
            case Range.OpenClosed:
                return value.CompareTo(start) > 0
                       && value.CompareTo(end) <= 0;
            case Range.ClosedOpen:
                return value.CompareTo(start) >= 0
                       && value.CompareTo(end) < 0;
            default:
                throw new ArgumentException($"Unknown parameter value {range}.", nameof(range));
        }
    }
}

তারপরে আপনি এটির মতো এটি ব্যবহার করতে পারেন:

var value = 5;
var start = 1;
var end = 10;

var result = value.IsWithin(start, end, Range.Closed);
— অলিভার
সূত্র
2

সম্পাদনা: নতুন উত্তর সরবরাহ করা হয়েছে। আমি যখন এই প্রশ্নের প্রথম উত্তরটি লিখেছিলাম তখন আমি সি # ব্যবহার করেই শুরু করছিলাম, এবং এই মুহূর্তে আমি বুঝতে পারি যে আমার "সমাধান" নিষ্পাপ এবং অদক্ষ।

আমার আসল উত্তর: আমি আরও সহজ সংস্করণ সহ যাব:

if(Enumerable.Range(1,100).Contains(intInQuestion)) { ...DoStuff; }

একটি ভাল উপায়

যেহেতু আমি অন্য কোনও সমাধান দেখতে পেলাম না যা আরও কার্যকর (কমপক্ষে আমার পরীক্ষাগুলি অনুসারে), আমি এটিকে আরও একবার দেব।

নেতিবাচক ব্যাপ্তিগুলির সাথে কাজ করে এমন নতুন এবং আরও ভাল উপায় :

// Returns true if x is in range [min..max], else false 
bool inRange(int x, int min=1, int max=100) => ((x - max)*(x - min) <= 0);

এটি ইতিবাচক এবং নেতিবাচক উভয় ব্যাপ্তি এবং বিভিন্ন সীমাতে ডিফল্ট ব্যবহার করা যেতে পারে

1..100 (সমেত) এবং ব্যবহারসমূহ xনম্বর হিসাবে একটি ঐচ্ছিক পরিসর দ্বারা সংজ্ঞায়িত দ্বারা অনুসরণ চেক করতে minএবং max।

ভাল পরিমাপের জন্য উদাহরণ যুক্ত করা

উদাহরণ 1:

// Returns true if x is in range [min..max], else false 
bool inRange(int x, int min=1, int max=100) => ((x - max)*(x - min) <= 0);

Console.WriteLine(inRange(25));
Console.WriteLine(inRange(1));
Console.WriteLine(inRange(100));
Console.WriteLine(inRange(25, 30, 150));
Console.WriteLine(inRange(-25, -50, 0));

রিটার্নস:

True
True
True
False
True

উদাহরণ 2: 1 এবং 150 এর মধ্যে এলোমেলো ইনটগুলির তালিকা ব্যবহার করে

// Returns true if x is in range [min..max], else false 
bool inRange(int x, int min=1, int max=100) => ((x - max)*(x - min) <= 0);

// Generate 100000 ints between 1 and 150
var intsToCheck = new List<int>();
var randGen = new Random();
for(int i = 0; i < 100000; ++i){
    intsToCheck.Add(randGen.Next(150) + 1);
}

var counter = 0;
foreach(int n in intsToCheck) {
    if(inRange(n)) ++counter;
}

Console.WriteLine("{0} ints found in range 1..100", counter);

রিটার্নস:

66660 ints found in range 1..100

সম্পাদনের সময়: 0.016 সেকেন্ড

— cseder
সূত্র
ইয়ে, আমি ২০১৩ সাল থেকে আমার উত্তরের একটি মন্তব্যে মন্তব্য করছি :) @ রায়ান দ্য লিচ: এই প্রশ্নের আমার উত্তর এখনকার "গৃহীত" উত্তর থেকে কীভাবে আলাদা? আমি বুঝতে পারি যে এটি সবচেয়ে কার্যকর ট্র্যাভারসাল নয়, তবে "ভয়ানক"? 100 ints এর মাধ্যমে বরাদ্দকরণ এবং লুপিং কতটা খারাপ হতে পারে? 1950 সালে সম্ভবত এটি সামাজিকভাবে গৃহীত হয়নি, তবে ...
— সিডেসার
@ রায়ান দ্য লেচ আমি আপনাকে দোষ দিচ্ছি না ... আমি আমার উত্তর আপডেট করেছি, সুতরাং, যদি আপনি আরও কার্যকর যে কোনও সমাধান সম্পর্কে জানেন তবে দয়া করে বিস্তারিত বলুন!
— ই
1
আমার মন্তব্যগুলি তারা আর দাঁড়াবে না তাই আমি মুছে ফেলেছি। ঠিক করার জন্য ধন্যবাদ, এটি ঠিক আছে বলে মনে হচ্ছে।
— রায়ান দ্য লিচ
1

পুরানো প্রিয়টিতে একটি নতুন টুইস্ট:

public bool IsWithinRange(int number, int topOfRange, int bottomOfRange, bool includeBoundaries) {
    if (includeBoundaries)
        return number <= topOfRange && number >= bottomOfRange;
    return number < topOfRange && number > bottomOfRange;
}
— বেন হফস্টিন
সূত্র
3
প্রকৃতপক্ষে চারটি মামলা রয়েছে, অন্তর্ভুক্ত / অন্তর্ভুক্ত, অন্তর্ভুক্ত / একচেটিয়া, একচেটিয়া / সমেত এবং একচেটিয়া / একচেটিয়া।
— উইলিয়াম টি। ম্যালার্ড
1

সি-তে, যদি সময়ের দক্ষতা গুরুতর হয় এবং পূর্ণসংখ্যার ওভারফ্লোগুলি মোড়ানো হয়, তবে কেউ তা করতে পারে if ((unsigned)(value-min) <= (max-min)) ...। যদি 'সর্বাধিক' এবং 'মিনিট' স্বতন্ত্র ভেরিয়েবল হয় তবে (সর্বাধিক মিনিট) অতিরিক্ত অতিরিক্ত বিয়োগ সময় নষ্ট করবে, তবে যদি সেই এক্সপ্রেশনটি সংকলন করতে গিয়ে প্রাক-সংক্ষিপ্ত করা যায়, বা রান-টাইমে একবার পরীক্ষা করে অনেকগুলি পরীক্ষা করা যায় একই পরিসরের বিপরীতে সংখ্যাগুলি, উপরের এক্সপ্রেশনটি দক্ষতার সাথে গুণ করা যেতে পারে এমনকি মান সীমাতে থাকা ক্ষেত্রেও (যদি মানগুলির একটি বৃহত ভগ্নাংশটি বৈধ সীমার নীচে থাকে তবে এটি ব্যবহার করা দ্রুত হতে পারে if ((value >= min) && (value <= max)) ...কারণ মানটি যদি তাড়াতাড়ি প্রস্থান করে তবে মিনিটের চেয়ে কম)।

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

— supercat
সূত্র
1

কিভাবে ভালো কিছু সম্পর্কে?

if (theNumber.isBetween(low, high, IntEx.Bounds.INCLUSIVE_INCLUSIVE))
{
}

এক্সটেনশন পদ্ধতির সাথে নিম্নরূপ (পরীক্ষিত):

public static class IntEx
{
    public enum Bounds 
    {
        INCLUSIVE_INCLUSIVE, 
        INCLUSIVE_EXCLUSIVE, 
        EXCLUSIVE_INCLUSIVE, 
        EXCLUSIVE_EXCLUSIVE
    }

    public static bool isBetween(this int theNumber, int low, int high, Bounds boundDef)
    {
        bool result;
        switch (boundDef)
        {
            case Bounds.INCLUSIVE_INCLUSIVE:
                result = ((low <= theNumber) && (theNumber <= high));
                break;
            case Bounds.INCLUSIVE_EXCLUSIVE:
                result = ((low <= theNumber) && (theNumber < high));
                break;
            case Bounds.EXCLUSIVE_INCLUSIVE:
                result = ((low < theNumber) && (theNumber <= high));
                break;
            case Bounds.EXCLUSIVE_EXCLUSIVE:
                result = ((low < theNumber) && (theNumber < high));
                break;
            default:
                throw new System.ArgumentException("Invalid boundary definition argument");
        }
        return result;
    }
}
— উইলিয়াম টি। ম্যালার্ড
সূত্র
1

আমি একটি রেঞ্জ অবজেক্ট করব, এরকম কিছু:

public class Range<T> where T : IComparable
{
    public T InferiorBoundary{get;private set;}
    public T SuperiorBoundary{get;private set;}

    public Range(T inferiorBoundary, T superiorBoundary)
    {
        InferiorBoundary = inferiorBoundary;
        SuperiorBoundary = superiorBoundary;
    }

    public bool IsWithinBoundaries(T value){
        return InferiorBoundary.CompareTo(value) > 0 && SuperiorBoundary.CompareTo(value) < 0;
    }
}

তারপরে আপনি এটি এভাবে ব্যবহার করুন:

Range<int> myRange = new Range<int>(1,999);
bool isWithinRange = myRange.IsWithinBoundaries(3);

আপনি অন্য ধরণের জন্য এটি পুনরায় ব্যবহার করতে পারেন।

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

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

    private double _epsilon = 10E-9;
    /// <summary>
    /// Checks if the distance between two doubles is within an epsilon.
    /// In general this should be used for determining equality between doubles.
    /// </summary>
    /// <param name="x0">The orgin of intrest</param>
    /// <param name="x"> The point of intrest</param>
    /// <param name="epsilon">The minimum distance between the points</param>
    /// <returns>Returns true iff x  in (x0-epsilon, x0+epsilon)</returns>
    public static bool IsInNeghborhood(double x0, double x, double epsilon) => Abs(x0 - x) < epsilon;

    public static bool AreEqual(double v0, double v1) => IsInNeghborhood(v0, v1, _epsilon);

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

    public enum BoundType
    {
        Open,
        Closed,
        OpenClosed,
        ClosedOpen
    }

অন্যান্য পদ্ধতি অনুসরণ করে:

    public static bool InRange(double value, double upperBound, double lowerBound, BoundType bound = BoundType.Open)
    {
        bool inside = value < upperBound && value > lowerBound;
        switch (bound)
        {
            case BoundType.Open:
                return inside;
            case BoundType.Closed:
                return inside || AreEqual(value, upperBound) || AreEqual(value, lowerBound); 
            case BoundType.OpenClosed:
                return inside || AreEqual(value, upperBound);
            case BoundType.ClosedOpen:
                return inside || AreEqual(value, lowerBound);
            default:
                throw new System.NotImplementedException("You forgot to do something");
        }
    }

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

— rahicks
সূত্র
1 
static class ExtensionMethods
{
    internal static bool IsBetween(this double number,double bound1, double bound2)
    {
        return Math.Min(bound1, bound2) <= number && number <= Math.Max(bound2, bound1);
    }

    internal static bool IsBetween(this int number, double bound1, double bound2)
    {
        return Math.Min(bound1, bound2) <= number && number <= Math.Max(bound2, bound1);
    }
}

ব্যবহার

দ্বিগুণ সংখ্যাটিওচেকড = 7;

var ফলাফল = সংখ্যাটিওবিচেকড.আইএসবিটিউন (100,122);

var ফলাফল = 5.IsBetween (100,120);

var ফলাফল = 8.0.Is এর মধ্যে (1.2,9.6);

— İব্রাহিম গজালোলু
সূত্র
1

আপনি যদি গৃহীত উত্তরের উপর @ ড্যাপের মন্তব্যে উদ্বিগ্ন হন এবং কেবল একবার মানটি পাস করতে পারেন তবে আপনি নীচের একটিটির চেষ্টা করতে পারেন

bool TestRangeDistance (int numberToCheck, int bottom, int distance)
{
  return (numberToCheck >= bottom && numberToCheck <= bottom+distance);
}

//var t = TestRangeDistance(10, somelist.Count()-5, 10);

অথবা 

bool TestRangeMargin (int numberToCheck, int target, int margin)
{
  return (numberToCheck >= target-margin && numberToCheck <= target+margin);
}

//var t = TestRangeMargin(10, somelist.Count(), 5);
— হুগো ডেলসিং
সূত্র
1

কমনীয়তার বিষয়ে, গাণিতিক স্বরলিপিটির নিকটতম জিনিস ( a <= x <= b ) সামান্য পাঠযোগ্যতার উন্নতি করে:

public static bool IsBetween(this int value, int min, int max)
{
    return min <= value && value <= max;
}

আরও উদাহরণের জন্য:

public static bool IsOutside(this int value, int min, int max)
{
    return value < min || max < value;
}
— ডহক্টর-J-রিভাস
সূত্র
0

আমি এটি করার জন্য একটি মার্জিত উপায় সন্ধান করছিলাম যেখানে সীমানা পরিবর্তন করা যেতে পারে (অর্থাত্ মানগুলি কোন ক্রমে রয়েছে তা নিশ্চিত নয়)।

এটি কেবল সি # এর নতুন সংস্করণগুলিতে কাজ করবে যেখানে?: বিদ্যমান রয়েছে

bool ValueWithinBounds(float val, float bounds1, float bounds2)
{
    return bounds1 >= bounds2 ?
      val <= bounds1 && val >= bounds2 : 
      val <= bounds2 && val >= bounds1;
}

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

— Kalikovision
সূত্র
0

মার্জিত কারণ এটি দুটি সীমানা মানগুলির মধ্যে কোনটি প্রথমে বড় তা নির্ধারণ করার প্রয়োজন নেই। এটিতে কোনও শাখা নেই।

public static bool InRange(float val, float a, float b)
{
    // Determine if val lies between a and b without first asking which is larger (a or b)
    return ( a <= val & val < b ) | ( b <= val & val < a );
}
— টম লেস
সূত্র
& + | বিটওয়াইজ অপারেটরগুলি
— নেলসন্ট্রুরান
0

আমি জানি না তবে আমি এই পদ্ধতিটি ব্যবহার করি:

    public static Boolean isInRange(this Decimal dec, Decimal min, Decimal max, bool includesMin = true, bool includesMax = true ) {

    return (includesMin ? (dec >= min) : (dec > min)) && (includesMax ? (dec <= max) : (dec < max));
}

এবং এটিই আমি এটি ব্যবহার করতে পারি:

    [TestMethod]
    public void IsIntoTheRange()
    {
        decimal dec = 54;

        Boolean result = false;

        result = dec.isInRange(50, 60); //result = True
        Assert.IsTrue(result);

        result = dec.isInRange(55, 60); //result = False
        Assert.IsFalse(result);

        result = dec.isInRange(54, 60); //result = True
        Assert.IsTrue(result);

        result = dec.isInRange(54, 60, false); //result = False
        Assert.IsFalse(result);

        result = dec.isInRange(32, 54, false, false);//result = False
        Assert.IsFalse(result);

        result = dec.isInRange(32, 54, false);//result = True
        Assert.IsTrue(result);
    }
— user8790965
সূত্র
দয়া করে কোড ব্লকের নীচে ব্যবহারের একটি উদাহরণ সরবরাহ করুন, এটি ওপিকে এটি তার উদ্দেশ্য অনুসারে ফিট করে কিনা তা জানতে সহায়তা করবে
— গ্যাব্রিয়েল বালসা ক্যান্ট
0

এগুলি কিছু এক্সটেনশন পদ্ধতি যা সহায়তা করতে পারে

  public static bool IsInRange<T>(this T value, T min, T max)
where T : System.IComparable<T>
    {
        return value.IsGreaterThenOrEqualTo(min) && value.IsLessThenOrEqualTo(max);
    }


    public static bool IsLessThenOrEqualTo<T>(this T value, T other)
         where T : System.IComparable<T>
    {
        var result = value.CompareTo(other);
        return result == -1 || result == 0;
    }


    public static bool IsGreaterThenOrEqualTo<T>(this T value, T other)
         where T : System.IComparable<T>
    {
        var result = value.CompareTo(other);
        return result == 1 || result == 0;
    }
— হানন
সূত্র
0

যদি এটি পদ্ধতির পরামিতিগুলি বৈধ করে তোলা হয় তবে সমাধানগুলির কোনওটিই আর্গুমেন্টআউটঅফ্র্যাঞ্জএক্সসেপশন ফেলে না এবং অন্তর্ভুক্ত / একচেটিয়া ন্যূনতম / সর্বোচ্চ মানগুলির সহজ / যথাযথ কনফিগারেশনের অনুমতি দেয় allow

এই মত ব্যবহার করুন

public void Start(int pos)
{
    pos.CheckRange(nameof(pos), min: 0);

    if (pos.IsInRange(max: 100, maxInclusive: false))
    {
        // ...
    }
}

আমি শুধু এই সুন্দর ফাংশন লিখেছি। বৈধ মানগুলির জন্য কোনও শাখা (একক যদি) না থাকারও সুবিধা রয়েছে। সবচেয়ে শক্ত অংশটি যথাযথ ব্যতিক্রম বার্তাগুলি খচিত করা।

/// <summary>
/// Returns whether specified value is in valid range.
/// </summary>
/// <typeparam name="T">The type of data to validate.</typeparam>
/// <param name="value">The value to validate.</param>
/// <param name="min">The minimum valid value.</param>
/// <param name="minInclusive">Whether the minimum value is valid.</param>
/// <param name="max">The maximum valid value.</param>
/// <param name="maxInclusive">Whether the maximum value is valid.</param>
/// <returns>Whether the value is within range.</returns>
public static bool IsInRange<T>(this T value, T? min = null, bool minInclusive = true, T? max = null, bool maxInclusive = true)
    where T : struct, IComparable<T>
{
    var minValid = min == null || (minInclusive && value.CompareTo(min.Value) >= 0) || (!minInclusive && value.CompareTo(min.Value) > 0);
    var maxValid = max == null || (maxInclusive && value.CompareTo(max.Value) <= 0) || (!maxInclusive && value.CompareTo(max.Value) < 0);
    return minValid && maxValid;
}

/// <summary>
/// Validates whether specified value is in valid range, and throws an exception if out of range.
/// </summary>
/// <typeparam name="T">The type of data to validate.</typeparam>
/// <param name="value">The value to validate.</param>
/// <param name="name">The name of the parameter.</param>
/// <param name="min">The minimum valid value.</param>
/// <param name="minInclusive">Whether the minimum value is valid.</param>
/// <param name="max">The maximum valid value.</param>
/// <param name="maxInclusive">Whether the maximum value is valid.</param>
/// <returns>The value if valid.</returns>
public static T CheckRange<T>(this T value, string name, T? min = null, bool minInclusive = true, T? max = null, bool maxInclusive = true)
where T : struct, IComparable<T>
{
    if (!value.IsInRange(min, minInclusive, max, maxInclusive))
    {
        if (min.HasValue && minInclusive && max.HasValue && maxInclusive)
        {
            var message = "{0} must be between {1} and {2}.";
            throw new ArgumentOutOfRangeException(name, value, message.FormatInvariant(name, min, max));
        }
        else
        {
            var messageMin = min.HasValue ? GetOpText(true, minInclusive).FormatInvariant(min) : null;
            var messageMax = max.HasValue ? GetOpText(false, maxInclusive).FormatInvariant(max) : null;
            var message = (messageMin != null && messageMax != null) ?
                "{0} must be {1} and {2}." :
                "{0} must be {1}.";
            throw new ArgumentOutOfRangeException(name, value, message.FormatInvariant(name, messageMin ?? messageMax, messageMax));
        }
    }
    return value;
}

private static string GetOpText(bool greaterThan, bool inclusive)
{
    return (greaterThan && inclusive) ? "greater than or equal to {0}" :
        greaterThan ? "greater than {0}" :
        inclusive ? "less than or equal to {0}" :
        "less than {0}";
}

public static string FormatInvariant(this string format, params object?[] args) => string.Format(CultureInfo.InvariantCulture, format, args);
— এতিয়েন চার্ল্যান্ড
সূত্র
-2

আপনি খুঁজছেন in [1..100]? এটি কেবল পাস্কাল।

— Polluks
সূত্র
2
সত্য নয়, এটি কেবল পাস্কাল নয়। অনেক আধুনিক ভাষায় এর মতো বৈশিষ্ট্য রয়েছে। কোটলিনে, উদাহরণস্বরূপ এটিকে "প্যাটার্ন ম্যাচিং" বলা হয়। উদাহরণ when (number) { in 0..9 -> println("1 digit") in 10..99 -> println("2 digits") in 100..999 -> println("3 digits") }
— this.myself
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.