আমি আপনার সাবনেটগুলিতে রয়েছি, আপনার কোডটি গল্ফ করছেন


17

চ্যালেঞ্জ

একটি IPv4 দেওয়া addressডটযুক্ত চতুর্ভুজ স্বরলিপি, এবং একটি IPv4 subnetমধ্যে কোন CIDR স্বরলিপি নির্ধারণ যদি addressহয় subnet। যদি এর মধ্যে থাকে তবে একটি স্বতন্ত্র এবং সামঞ্জস্যপূর্ণ মান আউটপুট করুন এবং এটিতে না থাকলে subnetএকটি পৃথক স্বতন্ত্র এবং সামঞ্জস্যপূর্ণ মান subnet। আউটপুট মানগুলি অবশ্যই আপনার ভাষায় সত্য / মিথ্যা হওয়ার দরকার নেই।

সিআইডিআর সাবনেট সংকেত সংক্ষিপ্ত প্রাইমার

আইপিভি 4 নেটওয়ার্কের ঠিকানাগুলি 32 বিট দৈর্ঘ্যে, পড়ার সুবিধার জন্য 8 টি বিটের চারটি গ্রুপে বিভক্ত। সিআইডিআর সাবনেট স্বরলিপিটি বামতম থেকে শুরু করে বিটগুলির নির্দিষ্ট সংখ্যার একটি মুখোশ । উদাহরণস্বরূপ, একটি /24সাবনেটের জন্য, এর অর্থ ঠিকানার 8-বিট ঠিকানার সেই সাবনেটে উপলব্ধ। সুতরাং দুটি ঠিকানা যা সর্বাধিক দ্বারা পৃথক করা হয় 255এবং একই সাবনেট মুখোশ রয়েছে, একই সাবনেটে রয়েছে। নোট করুন যে বৈধ সিআইডিআর-তে সমস্ত হোস্ট-বিট (ডানদিকে) আনসেট (জিরো) রয়েছে।

xxxxxxxx xxxxxxxx xxxxxxxx 00000000
^---    subnet mask   ---^ ^-hosts-^

অন্য উদাহরণের জন্য, একটি /32সাবনেট নির্দিষ্ট করে যে সমস্ত বিটগুলি সাবনেট মাস্ক, মূলত অর্থ প্রতি এক হোস্টের জন্য অনুমোদিত /32

xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx
^---        subnet mask        ---^

উদাহরণ:

ব্যবহার True"সাবনেট মধ্যে" এবং জন্য Falseজন্য আউটপুট হিসাবে "সাবনেট নেই":

127.0.0.1
127.0.0.0/24
True

127.0.0.55
127.0.0.0/23
True

127.0.1.55
127.0.0.0/23
True

10.4.1.33
10.4.0.0/16
True

255.255.255.255
0.0.0.0/0
True

127.1.2.3
127.0.0.0/24
False

127.1.2.3
127.1.2.1/32
False

10.10.83.255
10.10.84.0/22
False

বিধি এবং ব্যাখ্যা

  • ইনপুট পার্সিং এই চ্যালেঞ্জের আকর্ষণীয় বিন্দু নয়, তাই আপনাকে বৈধ IPv4 ঠিকানা এবং সাবনেট মাস্কগুলি পাওয়ার নিশ্চয়তা দেওয়া হচ্ছে।
  • ইনপুট এবং আউটপুট যে কোনও সুবিধাজনক পদ্ধতি দ্বারা দেওয়া যেতে পারে ।
  • আপনি ফলাফলটি মুদ্রণ করতে বা এটিকে কোনও কার্য ফলাফল হিসাবে ফিরিয়ে দিতে পারেন। আউটপুট কি মান নিতে পারে তা দয়া করে আপনার জমা দিন।
  • হয় একটি সম্পূর্ণ প্রোগ্রাম বা একটি ফাংশন গ্রহণযোগ্য।
  • স্ট্যান্ডার্ড লুফোলগুলি নিষিদ্ধ।
  • এটি তাই সাধারণ গল্ফিংয়ের সমস্ত নিয়ম প্রয়োগ হয় এবং সংক্ষিপ্ততম কোড (বাইটে) জয়ী হয়।

আপনার পরীক্ষার কেসগুলির মতো আমাদের কি একই ধরণের ইনপুট নিতে হবে?
অজ্ঞতার

1
@ এম্বোডিমেন্টফ অজানা আপনাকে উদাহরণগুলির মতো ওগুলিকে এক-প্রতি-লাইন হিসাবে নিতে হবে না, তবে উদাহরণ হিসাবে যেমন আপনাকে একটি বিন্দু-কোয়াড এবং ডটেড-সাবনেট হিসাবে গ্রহণ করা প্রয়োজন। (উদাহরণস্বরূপ, আর্নল্ডের জাভাস্ক্রিপ্টের উত্তর দেখুন)
অ্যাডমবর্কবার্ক

এগুলি কোনও স্ল্যাশ দ্বারা পৃথক করা ঠিক আছে, যেমন 10.0.0.1/10.0.0.0”/16?
নিক কেনেডি

1
@ পোকে আমি সম্মতি জানাই যে আপনি সিআইডিআর স্বরলিপিতে একটি আইপি ঠিকানা এবং একটি সাবনেট আকার বর্ণনা করেছেন correct হিসাবে, 1.255.1.1/8একটি বৈধ সিআইডিআর এক্সপ্রেশন , একটি সাবনেট মাস্ক সহ 1.255.1.1নেটওয়ার্কের মধ্যে হোস্টকে উপস্থাপন করে । তবে চ্যালেঞ্জটি সিআইডিআর স্বরলিপিতে বিশেষত নেটওয়ার্ক নম্বর এবং সাবনেটের জন্য জিজ্ঞাসা করে , যা কোনও বৈধ নেটওয়ার্ক নম্বর এবং সাবনেট সংমিশ্রণ নয়। 1.0.0.0255.0.0.01.255.1.1/8
640KB

1
এখন আমাদের এই চ্যালেঞ্জটির একটি আইপিভি 6 সংস্করণও দরকার
ফেরিবিগ

উত্তর:


13

পাইথন 3 (62 বাইট)

খুব সোজা:

from ipaddress import*
lambda i,m:ip_address(i)in ip_network(m)


3
অবশ্যই গাণিতিকের প্রতিটি কিছুর জন্য একটি বিল্ট-ইন রয়েছে - এমনকি এক্সোপ্ল্যানেটের জন্যও ! কিছুই এটাকে হারাতে পারে না ... তবে আপনি যেমন দেখতে পেতেন, পাইথন ম্যাথামেটিকাল এর ছাগল-formace সাথে মিলে যায়
agtoever

আমি অবাক হই যে , কোনও পাইথন-ভিত্তিক গল্ফিং ভাষা যদি না থাকে তবে সম্ভবত কোনও পাইথনকে বিজয়ী হতে দিয়ে যদি কোনও ip_adressবস্তু এবং কোনও ip_networkঅবজেক্ট গঠিত হয় any convenient method?
আমার সর্বনাম

আপনি এটি পাইথনের 20 বাইটের পরিসরে পাবেন না। কেবলমাত্র আমদানি এবং ল্যাম্বদা স্ট্যাক্স উত্তরের চেয়ে ইতিমধ্যে দীর্ঘ। গল্ফিংয়ের ভাষাগুলি "সাধারণ" ভাষা থেকে জিততে অবাক হওয়ার কিছু নেই ... :-(
agtoever

@ সোমোন: আমি পাইথনকে x86-64 মেশিন কোডের 53 বাইট দিয়ে পরাজিত করেছি । :) একটি traditionalতিহ্যবাহী গল্ফিং ভাষা নয় এবং কোড-আকারের বেশিরভাগ অংশ স্ট্রিং-> ইন ম্যানুয়ালি পার্স করছে। (host^net)>>(32-mask)মাত্র 10 বাইট তবে তালিকার তালিকাগুলি অন্তর্ভুক্ত না করা বা তালিকার উপরে কোনও ফাংশন ম্যাপিংয়ের জন্য এটি অর্ধেক পথ, কারণ অনেকগুলি স্কেলার অপারেশন 2 বা 3 বাইট নির্দেশের সাহায্যে করা যেতে পারে এবং কয়েকটি বাইটে জিনিসগুলির চারপাশে লুপগুলি নির্মিত যেতে পারে।
পিটার

4

সি # (ভিজ্যুয়াল সি # সংকলক) , 250 + 31 = 281 বাইট

(a,b)=>{Func<string,string>h=g=>string.Join("",g.Split('.').Select(x=>{var e=Convert.ToString(int.Parse(x),2);while(e.Length<8)e='0'+e;return e;}));a=h(a);var c=b.Split('/');b=h(c[0]);var d=int.Parse(c[1]);return a.Substring(0,d)==b.Substring(0,d);};

বাইটকাউন্টের অন্তর্ভুক্ত using System;using System.Linq;

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

আমি জেএসে এটি লিখেছিলাম চ্যালেঞ্জ পোস্ট হওয়ার সাথে সাথেই, তবে আরনাউল্ড আমাকে আরও ভাল উত্তর দিয়ে ঘুষিতে মারলেন, সুতরাং এখানে এটি পরিবর্তে সি # তে রয়েছে।

গল্ফ করার জন্য অবশ্যই অনেক জায়গা।

ব্যাখ্যা:

ফাংশনটিতে একটি উপ-ফাংশন থাকে h:

h=g=>string.Join("",
    g.Split('.').Select(x => {
        var e = Convert.ToString(int.Parse(x), 2);
        while (e.Length < 8) e = '0' + e;
        return e;
    }
);

এই উপ-ফাংশনটি আইপি অ্যাড্রেসটি বিভক্ত করে ., প্রতিটি সংখ্যাকে বাইনারি স্ট্রিংয়ে রূপান্তর করে , প্রতিটি স্ট্রিংকে 08-বিট লম্বা বাম-প্যাড দেয় , তারপরে স্ট্রিংগুলি 32-বিট বাইনারি স্ট্রিংয়ে সংযুক্ত করে।

এটি অবিলম্বে a=h(a);প্রদত্ত আইপি ঠিকানার সাথে জায়গায় জায়গায় করা হয়।
এরপরে আমরা সাবনেট মাস্কটি একটি আইপি ঠিকানা এবং একটি মাস্ক নম্বর দিয়ে বিভক্ত করিc=b.Split('/');

আইপি অ্যাড্রেস উপাদানটি আমাদের উপ-ফাংশনটির মধ্য দিয়েও গেছে: b=h(c[0]);এবং মুখোশ নম্বরটি পূর্ণসংখ্যায় পার্স করা হয়েছে:var d=int.Parse(c[1]);

অবশেষে আমরা dউভয় বাইনারি স্ট্রিংয়ের প্রথম বিটগুলি নিয়েছি ( dমাস্ক নম্বরটি কোথায় ) এবং তাদের তুলনা করুন:return a.Substring(0,d)==b.Substring(0,d);


1
এটি কাজ করে খুব ক্লান্ত হয়ে পড়েছি তাই আমি কেবল আপনার জন্য গল্ফ করেছি
মেয়াদোত্তীর্ণ ডেটা

1
আসলে প্যাডলিফ্ট সম্পর্কে ভুলে গেছেন এটিও অনলাইনে চেষ্টা করে দেখুন!
মেয়াদউত্তীর্ণ ডেটা

প্রচুর অপ্টিমাইজেশন। আপনাকে জানাতে পেরে আমি খুশি যে আপনি rPadএকটি অন্তর্নির্মিত স্ট্রিং। টিআইও লিঙ্কের পেস্টবিনের লিঙ্কটি যা খুব দীর্ঘ একা
আমার সর্বনাম

2
@someone ছোট অবগতির জন্য: মত URL সংক্ষিপ্ত tinyurl.com এই দঃপূঃ মন্তব্যের অনুমতি দেওয়া হয়, অধিকাংশ অসদৃশ। :)
কেভিন ক্রুইজসেন

1
188 - tinyurl.com/y6xfkbxt - চমৎকার URL সংক্ষেপিত টিপস @KevinCruijssen
Dana

4

লিনাক্স পসিক্স শেল (নেট-সরঞ্জাম / আইপুটিল সহ) (34 বাইট অব নন-টার্মিনেটিং, 47 বাইট সমাপ্ত)

নেটওয়ার্ক মাস্কস এবং অ্যাড্রেসগুলি নেটওয়ার্ক ইউটিলিটিগুলির তুলনায় পার্স করার পক্ষে সবচেয়ে উপযুক্ত কী? :)

route add -net $2 reject;! ping $1

সতর্কতা: স্ক্রিপ্টটি আপনার ইন্টারনেট সংযোগের জন্য সম্ভাব্য ক্ষতিকারক, দয়া করে যত্ন সহ চালান run

ইনপুট: স্ক্রিপ্টটি পরীক্ষিত আইপি ঠিকানাটিকে প্রথম আর্গুমেন্ট হিসাবে এবং পরীক্ষিত সাবনেট হিসাবে গ্রহণ করে। দ্বিতীয় যুক্তি হিসাবে।

আউটপুট: স্ক্রিপ্টটির প্রথম যুক্তি দ্বিতীয় আর্গুমেন্টে নির্দেশিত সাবনেটের অন্তর্ভুক্ত হলে স্ক্রিপ্টটি সত্যবাদী মান (0) প্রদান করে। অন্যথায়, এটি কখনই শেষ হবে না।

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


ব্যাখ্যা:

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


উদাহরণ

5.5.5.5 8.8.8.0/24 এর সাথে সম্পর্কিত কিনা তা পরীক্ষা করুন

$ sudo ./a.sh 5.5.5.5 8.8.8.0/24
PING 5.5.5.5 (5.5.5.5) 56(84) bytes of data.
[...runs forever...]

(দিয়ে পরিষ্কার করুন sudo ip route del 8.8.8.0/24কমান্ড চালানোর পরে )।

5.5.5.0/24 এর সাথে 5.5.5.5 আছে কিনা তা পরীক্ষা করুন:

$ sudo ./a.sh 5.5.5.5 5.5.5.0/24
connect: Network is unreachable
$ echo $?
0

(দিয়ে পরিষ্কার করুন sudo ip route del 5.5.5.0/24কমান্ড চালানোর পরে )।

8.8.8.8 5.5.5.0/24 এর সাথে সম্পর্কিত কিনা তা পরীক্ষা করুন:

$ sudo ./a.sh 8.8.8.8 5.5.5.0/24
PING 8.8.8.8 (8.8.8.8) 56(84) bytes of data.
64 bytes from 8.8.8.8: icmp_seq=1 ttl=122 time=2.27 ms
64 bytes from 8.8.8.8: icmp_seq=2 ttl=122 time=1.95 ms
[...runs forever...]

( sudo ip route del 5.5.5.0/24কমান্ড চালানোর পরে পরিষ্কার করুন )।


47-বাইট সংস্করণ যদি আমরা নন-টার্মিনেটিং স্ক্রিপ্টগুলি অস্বীকার করি

route add -net $2 reject;ping -c1 $1;[ $? = 2 ]

@ গ্রিমির মন্তব্য অনুসারে, এখানে সংস্করণটি সর্বদা বন্ধ হয়ে যায় এবং ঠিকানা সাবনেটে থাকলে 0 (সত্যবাদী) এবং অন্যথায় 1 (মিথ্যা) প্রদান করে returns আমরা পতাকাটি দিয়ে পিংকে সমাপ্ত করি -c1যা প্রেরিত প্যাকেটের সংখ্যা 1-এ সীমাবদ্ধ করে যদি ঠিকানাটি উত্তর দেয় তবে পিং 0 ফেরত আসবে, এবং যদি তা না হয় তবে পিংটি ফিরে আসবে 1. কেবল ঠিকানাটি যদি ব্ল্যাকহোল্ড সাবনেটের অন্তর্ভুক্ত থাকে তবে পিং 2 ফিরে আসবে, এটিই আমরা শেষ কমান্ডের বিরুদ্ধে পরীক্ষা করি।


3
যদিও চালাক, এই আউটপুট প্রয়োজন একটি স্বতন্ত্র এবং সুসংগত মান মেটাতে না পারে তাহলে ঠিকানা সাবনেট মধ্যে নয় ( চিরতরে চলমান একটি আউটপুট হিসাবে গণনা করা হয় না , তাও দেখতে এই )।
গ্রিমি 12

1
@ গ্রিমি: তবে এটি চুপচাপ চিরকালের জন্য চলবে না , তাই কেবল আপনার ২ য় লিঙ্কটি প্রযোজ্য, প্রথমটি নয়। এছাড়াও আমি মনে করি pingযে এটি সিডিপিআইপি থেকে মারা যাবে যদি এটি স্টাডাউট + স্টেডার দিয়ে চালিত হয় অন্য কোনও প্রোগ্রামে পাইপ করা হয়েছিল এবং পাঠক পাইপটি বন্ধ করে দিয়েছেন। এবং এটি সর্বাধিক ব্যবহারের ক্ষেত্রে হ'ল কারণ প্রস্থান স্থিতি কোনওভাবেই সাফল্য হতে পারে (যদি আমরা -c1গণনাটি সেট করার জন্য পিংয়ের বিকল্প যোগ করি ) তবে) তবে অবশ্যই, এর আউটপুটটি পড়া var=$(/a.sh)ব্যর্থ হবে; আপনার এমন পাঠক দরকার যা পুরো আউটপুটটি পড়া এবং তারপরে দেখার চেয়ে সিদ্ধান্ত নেওয়ার পরে থামে।
পিটার কর্ডস

@ গ্রিমি ফেয়ার পয়েন্ট (যদিও যুক্তির পক্ষে আমি বলতে পারি যে আমাদের এখানে দুটি ধারাবাহিক মান রয়েছে, যেহেতু pingব্ল্যাকহোল্ড ঠিকানার ক্ষেত্রে এক সেকেন্ডের চেয়ে কম হয়ে যাবে)। আমি অতিরিক্ত 13 বাইটের জন্য একটি সমাপ্তি সংস্করণ যুক্ত করেছি! :)
ইয়োন


3

পিএইচপি , 101 92 88 বাইট

@ গাউগ থেকে -13 বাইট

function($i,$r){[$r,$n]=explode('/',$r);return(ip2long($i)&~(1<<32-$n)+1)==ip2long($r);}

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


2
এটি গল্ফ করে কিছুটা মজা function($i,$r){return!((ip2long($i)^ip2long(strtok($r,'/')))>>32-strtok(_));}
ক্রিস্টোফ

@ ক্রিসটফ খুব সুন্দর! আমার কাছে কখনও ঘটেনি যে আপনি কেবল দ্বিতীয় কল করার জন্য কোনও টোকেন ব্যবহার করতে পারেন strtok()। আপনার নীচের আমার অনুরূপ উত্তরের চেয়ে 4 বাইট কম sh সাজসরঞ্জাম!
640KB

@ ক্রিসটফ আপনার নিজের সমাধানটি আলাদা উত্তর হিসাবে পোস্ট করুন কারণ এটি আমার চেয়ে ভাল।
লুইস ফিলিপ দে জেসুস মুনোজ

3

পাওয়ারপিসি / পিপিসি 64 সি, 116 114 বাইট

#include<stdio.h>
main(){unsigned u[4];char*p=u;for(;p<u+3;)scanf("%hhu%c",p++,u+3);return!((*u^u[1])>>32-p[-4]);}

(Xx__Ubuntu 18.04 তে পাওয়ারপিসি 64-লিনাক্স-গনু-জিসিসি-স্ট্যাটিক এবং কিউমু-ব্যবহারকারী ব্যবহার করে পরীক্ষিত হয়েছে))

প্রোগ্রামটি স্ট্যান্ডার্ড ইনপুটটিতে দুটি লাইন নিয়ে যায় এবং এর প্রস্থান কোড হিসাবে এটি ঠিকানাটি মেলে যদি 1 এবং এটি না মানলে 0 ফেরত দেয়। (সুতরাং এটি ম্যাচের জন্য সত্যবাদী মান এবং কোনও অমিলের জন্য মিথ্যা মানের প্রয়োজন নেই এমন স্পেসিফিকেশনের উপর নির্ভর করে)) নোট করুন যে আপনি যদি ইন্টারেক্টিভভাবে চালিয়ে যাচ্ছেন ^Dতবে দ্বিতীয় লাইনে প্রবেশের পরে আপনাকে তিনবার ইওএফ ( ) সিগন্যাল করতে হবে ।

এটি পাওয়ারপিসি বড়-এন্ডিয়ান হওয়ার উপর নির্ভর করে, এবং সেই প্ল্যাটফর্মটিতে 0-এ 32-বিট স্বাক্ষরিত মানটি 32-র দ্বারা ডান স্থানান্তরিত করার জন্য 0-এ ফিরে আসে oc এটি অটকটকে স্বাক্ষরিত মানগুলিকে এক-এক করে পাঠায়, অন্য বাইটের নেটমাস্ক দৈর্ঘ্যের পাশাপাশি reads ; তারপরে এটি দুটি স্বাক্ষরযুক্ত 32-বিট ঠিকানার জোর লাগবে এবং অপ্রাসঙ্গিক বিটগুলি সরিয়ে ফেলবে। অবশেষে, এটি !কেবলমাত্র দুটি স্বতন্ত্র মান প্রত্যাবর্তনের প্রয়োজনীয়তা পূরণ করতে প্রযোজ্য ।

দ্রষ্টব্য: এটি পারে প্রতিস্থাপন দুটি বাইট বন্ধ শেভ করা সম্ভব হতে u+3সঙ্গে pসঙ্গে সংকলন প্রয়োজন -O0। যদিও আমার যত্নের চেয়ে এটি বিপজ্জনকভাবে জীবনযাপন করছে।

এই সমাধানের অনুপ্রেরণার জন্য পিটার কর্ডসকে ধন্যবাদ।


আরও বহনযোগ্য সি, 186 171 167 বাইট

এখানে আমি আরও বহনযোগ্য সংস্করণ সংরক্ষণ করব যা 167 বাইট চালায়।

#include<stdio.h>
main(){unsigned a,b,c,d,e,f,g,h,n;scanf("%u.%u.%u.%u %u.%u.%u.%u/%u",&a,&b,&c,&d,&e,&f,&g,&h,&n);return!(n&&((((a^e)<<8|b^f)<<8|c^g)<<8|d^h)>>32-n);}

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

মূল এক্সপ্রেশনটির একটি ভাঙ্গন:

  • a^e, b^f, c^g, d^hঠিকানার XOR এবং বাইট-বাই-বাইট মাস্ক হিসাব করে।
  • (((a^e)<<8|b^f)<<8|c^g)<<8|d^h তারপরে হর্নার জাতীয় পদ্ধতিতে এগুলিকে একক স্বাক্ষরযুক্ত 32-বিট মান হিসাবে একত্রিত করে।
  • ...>>32-nতারপরে সাবটার মাস্কের সাথে প্রাসঙ্গিক নয় এমন জোরের পার্থক্যের বিটগুলি সরিয়ে ফেলুন ( -সি এর চেয়ে উচ্চতর প্রাধান্য রয়েছে তা মাথায় রেখে <<)
  • একটি গ্যাচা রয়েছে, যদিও: যদি এন = 0 হয় তবে 32 বিট (এটি কার্যত সমস্ত বর্তমান প্ল্যাটফর্মের উপর রয়েছে) ~0U<<32ধরে unsignedনেওয়া অবধারিত আচরণ দেবে । অন্যদিকে, যদি এন = 0 হয় তবে কোনও ঠিকানা মিলবে, তাই n&&...সঠিক ফলাফল দেবে (এর সংক্ষিপ্ত-প্রচারের আচরণের সুযোগ নিয়ে &&)।
  • পরিশেষে, আউটপুট কেবল দুটি মানগুলির মধ্যে একটি হতে পারে সেই প্রয়োজনীয়তাটি পূরণ করার জন্য, আমরা !আউটপুট 0 বা 1 এ প্রয়োগ করি ।

সিলিংক্যাট এবং অ্যাডমবর্কবার্কের মন্তব্যের কারণে -15 বাইট

পিটার কর্ডসের মন্তব্যের কারণে -4 বাইট


1
মানগুলি ফেরত দিতে প্রস্থান কোডগুলি ব্যবহার করা ডিফল্ট I / O পদ্ধতিগুলির মধ্যে একটি এবং এটি অনুমোদিত।
অ্যাডমবর্কবার্ক

@ এসিলিংক্যাট অবশ্যই আমার যে নির্বোধ তা মিস করছি।
ড্যানিয়েল শেপলার

@ অ্যাডমবার্কবার্ক ঠিক আছে, ধন্যবাদ, আমি প্রস্থান কোডটি ব্যবহার করার জন্য এটি পরিবর্তন করেছি।
ড্যানিয়েল শেপলার

ধারণা: সামান্য এন্ডিয়ান বা বিগ-এন্ডিয়ান সি বাস্তবায়ন লক্ষ্য করুন (কোড-গল্ফের পোর্টেবল কোডের প্রয়োজন হয় না) এবং টাইপ-পান আউটপুট পয়েন্টারগুলির বাইটে unsigned। উদাহরণস্বরূপ char*p=&aতখন p++,p++,p++,...বা p--,...স্ক্যানফ আরগস হিসাবে। বিন্যাস স্ট্রিং হতে করতে হবে "%hhu.%hhu...", যদিও তাই এটি কম Vars ঘোষণা কি করতে সক্ষম হচ্ছে বনাম যে অতিরিক্ত আকার মধ্যে উল্লেখযোগ্য ট্রেড বন্ধ আছে(a^b)>>(32-count)
পিটার Cordes

1
ধন্যবাদ পিটারকর্ডস ইউপ, ডান শিফট কাজ করে, ধন্যবাদ।
ড্যানিয়েল শেপলার

2

স্ট্যাক্স , 22 বাইট

é.○▄╗jF⌐§╥§I╓☻lw«ç┴║╫┼

এটি চালান এবং এটি ডিবাগ করুন

এটি স্ট্যান্ডার্ড ইনপুট-এ পৃথক ইনপুট পরামিতিগুলি নেয়।

আনপ্যাকড, নিরবচ্ছিন্ন এবং মন্তব্য করা হয়েছে, এটি দেখতে এমন দেখাচ্ছে।

'/:/~       split on slash and push the last group back to the input stack
j{          split on space; for each group, run this code block
  './       split on period
  {emVB|E   evaluate integers and decode integer as base-256
  ;e|<      peek from input stack and shift left
  Vu/       integer divide by 2^32
F           end of for-each
=           two values left on stack are equal?

এটি চালান


2

x86-64 মেশিন কোড ফাংশন, 53 48 বাইট

পরিবর্তণের:

  • বিশেষ ক্ষেত্রে jzপরিচালনা করতে 64৪-বিট শিফট ব্যবহার না করে শিফটের ওপরে -2 >>(32-0)
  • -3 এর পরিবর্তে জেডএফ-এ ফিরে আসার জন্য 3 টি বাইট সংরক্ষণ করুন setnz al

( এটির উপর ভিত্তি করে ড্যানিয়েল শেপলারের ৩২-বিট মেশিন কোড উত্তরও দেখুন , যা আমাদের অন্যান্য কিছু ধারণাগুলি ব্যবহার করতে বিকশিত হয়েছিল I'm আমি এই উত্তরটির নীচে আমার সর্বশেষ সংস্করণটিও অন্তর্ভুক্ত করছি))


সাবনেটে নয় হোস্টের জন্য জেডএফ = 0 , সাবনেটে জেডএফ = 1 প্রদান করে, যাতে আপনি ফলাফলের সাথে শাখা করতে পারেনje host_matches_subnet

X86-64 সিস্টেম ভি কলিং কনভেনশনের সাথে কল করা
bool not_in_subnet(int dummy_rdi, const char *input_rsi);যেন আপনি যুক্ত করে থাকেন setnz al

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

আমরা একই আইটভিড-কোয়াড পার্স লুপটি 3 বার চালনা করি, দুটি আইপিভি 4 অ্যাড্রেস পেয়ে এবং /maskএকটি শব্দের উচ্চ বাইটে একটি পূর্ণসংখ্যা হিসাবে পেয়ে যাচ্ছি। (এই কারণেই এখানে পঠনযোগ্য স্মৃতি থাকতে হবে /maskতবে এএসসিআইআই সংখ্যা রয়েছে কিনা তা বিবেচ্য নয়))

আমরা(host ^ subnet) >> (32-mask) সাবনেট এবং হোস্টের মধ্যে কেবলমাত্র পার্থক্য রেখে হোস্ট বিটগুলি পরিবর্তন করতে পারি (যাহা মেলে না এমন)। /0আমাদের 32 টি শিফট করতে হবে এমন বিশেষ কেসটি সমাধান করার জন্য, আমরা কাউন্ট = 0 এ শিফ্টের ওপরে উঠি। ( neg clজেডএফ সেট করে, যা আমরা শাখা করতে পারি এবং আমরা যদি শিফট না করি তবে রিটার্ন মান হিসাবে ছেড়ে যেতে পারি)) নোট করুন 32-mask mod 32 = -mask, এবং x86 স্কেলার শিফটগুলি তাদের গণনাটি মাস্ক & 31বা দ্বারা মাস্ক করে & 63

    line  addr   machine                NASM source.  (from nasm -felf64 -l/dev/stdout)
    num          code bytes

     1                             %use smartalign
     2                             
     3                                 ;10.4.1.33 10.4.0.0/23         true
     4                                 ;10.4.1.33 10.4.0.0/24         false
     5                             
     6                             ;; /codegolf/185005/im-in-your-subnets-golfing-your-code
     7                             %ifidn __OUTPUT_FORMAT__, elf64
     8                             in_subnet:
     9                             
    10 00000000 6A03                   push 3
    11 00000002 5F                     pop  rdi                    ; edi = 3 dotted-quads to parse, sort of.
    12                             .parseloop:
    13                             
    14                                 ;xor  ebx,ebx             ; doesn't need to be zeroed first; we end up shifting out the original contents
    15                                 ;lea  ecx, [rbx+4]
    16 00000003 6A04                   push   4
    17 00000005 59                     pop    rcx                  ; rcx = 4 integers in a dotted-quad
    18                             .quadloop:
    19                             
    20 00000006 31D2                   xor   edx,edx               ; standard edx=atoi(rdi) loop terminated by a non-digit char
    21 00000008 EB05                   jmp  .digit_entry
    22                              .digitloop:
    23 0000000A 6BD20A                 imul   edx, 10
    24 0000000D 00C2                   add    dl, al
    25                              .digit_entry:
    26 0000000F AC                     lodsb
    27 00000010 2C30                   sub    al, '0'
    28 00000012 3C09                   cmp    al, 9
    29 00000014 76F4                   jbe   .digitloop
    30                                 ; al=non-digit character - '0'
    31                                 ; RDI pointing to the next character.
    32                                 ; EDX = integer
    33                             
    34 00000016 C1E308                 shl    ebx, 8
    35 00000019 88D3                   mov    bl, dl               ; build a quad 1 byte at a time, ending with the lowest byte
    36 0000001B E2E9                   loop .quadloop
    37                             
    38 0000001D 53                     push   rbx          ; push result to be collected after parsing 3 times
    39 0000001E FFCF                   dec    edi
    40 00000020 75E1                   jnz   .parseloop
    41                             
    42 00000022 59                     pop    rcx   ; /mask  (at the top of a dword)
    43 00000023 5A                     pop    rdx   ; subnet
    44 00000024 58                     pop    rax   ; host
    45 00000025 0FC9                   bswap  ecx   ; cl=network bits  (reusing the quad parse loop left it in the high byte)

    49 00000027 F6D9                   neg    cl
    50 00000029 7404                   jz   .all_net     ; skip the count=32 special case
    51                             
    52 0000002B 31D0                   xor    eax, edx   ; host ^ subnet
    53 0000002D D3E8                   shr    eax, cl    ; shift out the host bits, keeping only the diff of subnet bits
    54                             
    55                             .all_net:
    56                                ; setnz  al         ; return ZF=1 match,  ZF=0 not in subnet
    57 0000002F C3                     ret
    58 00000030 30                 .size:      db $ - in_subnet

              0x30 = 48 bytes

(সর্বশেষ সংস্করণ সহ আপডেট করা হয়নি) অনলাইনে চেষ্টা করুন!

_startএটির সাথে এটি কল করে argv[1]এবং একটি প্রস্থান স্থিতি ফেরত দেয় including

## on my desktop
$ ./ipv4-subnet "10.4.1.33 10.4.0.0/24"    && echo "$? : in subnet" || echo "$? : not in subnet"
not in subnet

$ ./ipv4-subnet "10.4.1.33 10.4.0.0/23"    && echo "$? : in subnet" || echo "$? : not in subnet"
in subnet

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


x86 32-বিট মেশিন কোড ফাংশন, 38 বাইট

9 টি পূর্ণসংখ্যা করুন -> uint8_t পার্স করুন এবং তাদের স্ট্যাকের উপর "চাপুন", যেখানে আমরা সেগুলি ডিফল্ট হিসাবে পপ করি বা শেষটি এখনও সিএলে ব্যবহার করি। স্ট্রিংয়ের শেষটি পড়া মোটেও এড়ানো যায় না।

এছাড়াও, dec32-বিট মোডে কেবল 1 বাইট।

    72                             in_subnet:
    73 00000000 89E7                   mov   edi, esp
    74 00000002 51                     push  ecx
    75 00000003 51                     push  ecx                   ; sub esp,8
    76                             .byteloop:
    77                             
    78 00000004 31C9                   xor   ecx,ecx               ; standard ecx=atoi(rdi) loop terminated by a non-digit char
    79                                                             ; runs 9 times: 8 in two dotted-quads, 1 mask length
    80 00000006 EB05                   jmp  .digit_entry
    81                              .digitloop:
    82 00000008 6BC90A                 imul   ecx, 10
    83 0000000B 00C1                   add    cl, al
    84                              .digit_entry:
    85 0000000D AC                     lodsb
    86 0000000E 2C30                   sub    al, '0'
    87 00000010 3C09                   cmp    al, 9
    88 00000012 76F4                   jbe   .digitloop
    89                                 ; RDI pointing to the next character.
    90                                 ; EDX = integer
    91                             
    92 00000014 4F                     dec    edi
    93 00000015 880F                   mov    [edi], cl           ; /mask store goes below ESP but we don't reload it
    94 00000017 39E7                   cmp    edi, esp
    95 00000019 73E9                   jae   .byteloop
    96                             
    97                                 ;; CL = /mask still there from the last conversion
    98                                 ;; ESP pointing at subnet and host on the stack, EDI = ESP-1
    99                             
   100 0000001B 5A                     pop    edx   ; subnet
   101 0000001C 58                     pop    eax   ; host
   102                             
   103 0000001D 31D0                   xor    eax, edx             ; host ^ subnet
   104 0000001F F6D9                   neg    cl                   ; -mask = (32-mask) mod 32;  x86 shifts mask their count
   105 00000021 7402                   jz     .end                 ; 32-n = 32 special case
   106 00000023 D3E8                   shr    eax, cl
   107                             .end:
   108                                 ; setz  al                  ; just return in ZF
   109 00000025 C3                     ret

   110 00000026 26                 .size:      db $ - in_subnet
      0x26 = 38 bytes

টেস্ট কলার

   113                             global _start
   114                             _start:
   115 00000027 8B742408               mov    esi, [esp+8]   ; argv[1]
   116 0000002B E8D0FFFFFF             call   in_subnet
   117 00000030 0F95C3                 setnz  bl
   118 00000033 B801000000             mov    eax, 1         ; _exit syscall
   119 00000038 CD80                   int    0x80

আমি আগ্রহী যে 32-বিট asm বাইট গণনাটি কীভাবে যায় যদি cmp/jccআপনি উল্লিখিত পরিবর্তে আপনি যেমন কিছু করেছিলেন xor edx,edx;neg cl;cmovz eax,edx;shr eax,cl- বা সম্ভবত আপনার ইতিমধ্যে কোথাও কোথাও 0 টি মান ঝুলছে। (এবং তারপরে আপনার কোনও sub cl,32নির্দেশের দরকার পড়বে না ))
ড্যানিয়েল শেপলার

1
হ্যাঁ, ediলুপটি যখন প্রস্থান করে তখন 0 xor eax,edx;neg cl;cmovz eax,edi;shr eax,clহওয়া উচিত , সুতরাং কাজ করা উচিত।
ড্যানিয়েল শেপলার

1
আমি যদি জিনিসগুলি সঠিকভাবে গণনা করি তবে cmove eax,edi3 বাইট রয়েছে যা মুছে ফেলার sub cl,32পরে ধুয়ে ফেলতে পারে তবে shr cl,eaxএকটি বাইট ওভার সাশ্রয় করে shr cl,raxএবং 32-বিট dec ediএকটি বাইটকে 64-বিটেরও বেশি সাশ্রয় করে dec edi। আমার সমাবেশ তারপরে .byte 0x33(জিএনইউ বাইনুটিস সিনট্যাক্সে) = 51 দেয় in_subnet.size
ড্যানিয়েল শেপলার

ভাল ধারণা, ধন্যবাদ। (ইন্টেল সিনট্যাক্সে এটি shr eax,cl, বনাম shr %cl, %eaxএটিএন্ডটি সিনট্যাক্সে, আপনার শেষ মন্তব্যটি এর বিপরীত হয়েছে)) মেশিন-কোড উত্তরগুলি আপডেট করার জন্য (এবং _startকলারটিকে পোর্ট করা এবং 32-বিট মোডের জন্য কলিং কনভেনশনটিকে পুনরায় বর্ণনা করা ) একটি বিরল কাজ .. ।), তাই আমি এটির কাছাকাছি নাও যেতে পারি। আজ অলস লাগছে। >। <
পিটার

1
ডাবল লুপ থেকে মুক্তি পাওয়ার পরিবর্তে এবং স্ট্যাক ভেরিয়েবলগুলিতে সঞ্চয় করার বিষয়ে আপনি যে উত্তরটি দিয়েছেন তাতে আমি কেবল প্রয়োগ করার চেষ্টা করেছি - এমনকি রাইট পয়েন্টারটি ediইনপুট করতে, আউটপুট লিখতে ইত্যাদির অতিরিক্ত কোড দিয়েও এটি 2 বাইট সংরক্ষণ করে শেষ করে জালে (একবার আমি উপলব্ধি অন্তত push ecx;push ecx;push ecxচেয়ে খাটো ছিল sub esp,12; এবং এটি একটি ধোয়ার হতে যাচ্ছিলেন কিনা আমি predecremented ediএবং ব্যবহৃত std;stosb;cldঅথবা আমি শুধু ব্যবহার সঞ্চিত dec edi;mov [edi],al
ড্যানিয়েল Schepler

1

জেলি , 23 বাইট

ṣ”/ṣ€”.Vḅ⁹s2+Ø%BḊ€ḣ€ʋ/E

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

মোনাডিক লিঙ্ক যা কোনও ঠিকানা এবং সাবনেটকে স্ল্যাশ দ্বারা পৃথক করে এবং সত্যের জন্য 1 এবং মিথ্যা হিসাবে 0 প্রদান করে takes

মূলটিতে একটি ত্রুটি দেখানোর জন্য @ গৌগফকে ধন্যবাদ - বাইনারি তালিকাটি 32 টি দীর্ঘ ছিল তা নিশ্চিত করতে ব্যর্থ হয়েছে



1

05AB1E, 21 bytes

'/¡`U‚ε'.¡b8jð0:JX£}Ë

Takes the subnet before the address.

Try it online or verify all test cases.

Explanation:

'/¡              '# Split the first subnet-input by "/"
   `              # Push both values separated to the stack
    U             # Pop and store the trailing number in variable `X`
                 # Pair the subnet-IP with the second address-input
     ε            # Map both to:
      '.¡        '#  Split on "."
         b        #  Convert each integer to binary
          8j      #  Add leading spaces to make them size 8
          ð0:     #  And replace those spaces with "0"
             J    #  Join the four parts together to a single string
              X£  #  And only leave the first `X` binary digits as substring
                # After the map: check if both mapped values are the same
                  # (which is output implicitly as result)

1

R 120 bytes

a function - I pasted ".32" to first term

w=function(a,b){f=function(x)as.double(el(strsplit(x,"[./]")));t=f(paste0(a,".32"))-f(b);sum(t[-5]*c(256^(3:0)))<2^t[5]}

and just for fun:

require("iptools");w=function(a,b)ips_in_cidrs(a,b)[[2]]

which is 56 bytes


1

PHP, 75 73, 71 bytes

<?=strtok($argv[2],'/')==long2ip(ip2long($argv[1])&1+~1<<32-strtok(_));

A fork of @Luis felipe De jesus Munoz's answer, as a standalone taking input from command line args. Outputs '1' for Truthy, '' (empty string) for Fasley.

$ php ipsn.php 127.0.0.1 127.0.0.0/24
1
$ php ipsn.php 127.1.2.3 127.0.0.0/24

Try it online!

-2 bytes borrowing @Christoph's little trick for strtok(). His answer is still shorter though!


1

x86 assembly function, 49 43 bytes

This is mostly posted to satisfy Peter Cordes's request for the revised version I created. It can probably go away once/if he incorporates it into his answer.

This function expects esi to point to an input string, with the address and subnet parts separated either by a space or a newline character, and the return value is in the ZF flag (which by definition has only two possible values).

 1                                  %use smartalign
 2                                  
 3                                      ;10.4.1.33 10.4.0.0/23         true
 4                                      ;10.4.1.33 10.4.0.0/24         false
 5                                  
 6                                  ;; /codegolf/185005/im-in-your-subnets-golfing-your-code
 7                                  in_subnet:
 8                                  
 9                                      ;xor  ebx,ebx             ; doesn't need to be zeroed first; we end up shifting out the original contents
10                                      ;lea  ecx, [rbx+4]
11 00000000 6A09                        push   9
12 00000002 59                          pop    ecx                  ; ecx = 9 integers (8 in two dotted-quads,
13                                                                  ; 1 mask length)
14                                  
15 00000003 89E7                        mov   edi, esp
16 00000005 83EC0C                      sub   esp, 12
17                                  .quadloop:
18                                  
19 00000008 31D2                        xor   edx,edx               ; standard edx=atoi(rdi) loop terminated by a non-digit char
20 0000000A EB05                        jmp  .digit_entry
21                                   .digitloop:
22 0000000C 6BD20A                      imul   edx, 10
23 0000000F 00C2                        add    dl, al
24                                   .digit_entry:
25 00000011 AC                          lodsb
26 00000012 2C30                        sub    al, '0'
27 00000014 3C09                        cmp    al, 9
28 00000016 76F4                        jbe   .digitloop
29                                      ; al=non-digit character - '0'
30                                      ; RDI pointing to the next character.
31                                      ; EDX = integer
32                                  
33 00000018 4F                          dec    edi
34 00000019 8817                        mov    [edi], dl
35 0000001B E2EB                        loop .quadloop
36                                  
37 0000001D 59                          pop    ecx   ; /mask  (at the top of a dword)
38 0000001E 5A                          pop    edx   ; subnet
39 0000001F 58                          pop    eax   ; host
40 00000020 0FC9                        bswap  ecx   ; cl=network bits  (reusing the quad parse loop left it in the high byte)
41                                  
42                                  ;    xor    cl, -32    ; I think there's some trick like this for 32-n or 31-n, but maybe only if we're masking to &31?  Then neg or not work.
43                                  
44 00000022 31D0                        xor    eax, edx   ; host ^ subnet
45                                  ;    xor    edx, edx   ; edx = 0
46 00000024 F6D9                        neg    cl
47 00000026 7402                        jz     .end
48 00000028 D3E8                        shr    eax, cl    ; count=32 special case isn't special for a 64-bit shift
49                                  .end:    
50 0000002A C3                          ret
51 0000002B 2B                      .size:      db $ - in_subnet

And the x86 Linux wrapper part:

53                                  global _start
54                                  _start:
55 0000002C 8B742408                    mov    esi, [esp+8]   ; argv[1]
56 00000030 E8CBFFFFFF                  call   in_subnet
57 00000035 0F95C0                      setnz  al
58 00000038 0FB6D8                      movzx  ebx, al
59 0000003B B801000000                  mov    eax, 1         ; _exit syscall
60 00000040 CD80                        int    0x80

-6 bytes due to suggestion from Peter Cordes to return the value in ZF.


I guess I could save one byte by removing the last xor edx,edx and replacing cmovz eax,edx with jz .nonzero; xor eax,eax; .nonzero:. cmovz still wins if we have calling convention ebx=0.
Daniel Schepler

Can we just jz over the shr to the setz or the ret? We can swap the setnz to setz and return 1 for a match if that helps. Or even say that our return value is ZF. I should have done that in my answer. (But I don't think we can justify requiring the caller to create constants for us, like ebx=0. My answer on Tips for golfing in x86/x64 machine code argues that would be stretching a custom calling convention too far.
Peter Cordes

BTW, I use cut to remove some columns from the NASM listing output because all my instructions are short: nasm -felf foo.asm -l/dev/stdout | cut -b -34,$((34+6))-. Also, I used mov instead of movzx in my _start caller because the exit status comes from the low byte of the arg to sys_exit(). The kernel ignores the higher bytes.
Peter Cordes

I guess that would work. That takes the count down to 43 bytes and then I insert setnz al after call in_subnet in the wrapper.
Daniel Schepler

Yup. Easy to imagine the normal use case for this function would be call/je, rather than printing or further passing along the result. Like I pointed out in the "tips", some system-call calling conventions already do this in real life (usually with CF=error).
Peter Cordes

1

Java 215 211 207 202 200 199 198 190 180 bytes

Long k,c;boolean a(String i,String s){return(b(i)^b(s))>>32-k.decode(s.split("/")[1])==0;}long b(String i){for(c=k=0l;c<4;k+=k.decode(i.split("[./]")[3+(int)-c])<<8*c++);return k;}

Outputs true for truthy and false for falsy.

Note: This uses long instead of int for the potential right shift of 32.

Try it online!

Saved 1 byte thanks to ceilingcat

Saved 10 bytes thanks to Peter Cordes


This doesn't output a "distinct and consistent value" for falsey.
AdmBorkBork

I'd argue that it's distinctly and consistently non-zero but if that's not the spirit of the challenge, I can change it.
Poke

A 64-bit integer supports left-shifts by 32. Also, you can right shift host ^ net to shift out the bits you want to remove, instead of actually creating a mask. But I guess Java needs a compare in there to create a boolean from an integer. Maybe a !, because it doesn't matter which of true or false you produce for which output. (I asked the OP for clarification about whether they intended to exclude 0 / non-zero, and they said yes they were aware of the consequences of that wording:
Peter Cordes

1
@PeterCordes Converting everything to long does lose me some bytes but I make up for it by being able to remove the ternary and doing the XOR as you suggest. I'm checking what else I can golf before posting
Poke

1

Charcoal, 36 bytes

≔⪪S/θ≔I⊟θζ⊞θSUMθ÷↨I⪪ι.²⁵⁶X²⁻³²ζ⁼⊟θ⊟θ

Try it online! Link is to verbose version of code. Takes the subnet as the first parameter and and outputs - only if the address lies within the subnet. Explanation:

≔⪪S/θ

Split the subnet on /.

≔I⊟θζ

Remove the mask and cast it to integer.

⊞θS

Push the address to the array.

UMθ÷↨I⪪ι.²⁵⁶X²⁻³²ζ

Split both addresses on ., convert them to integers, interpret as base 256, and discard the masked bits.

⁼⊟θ⊟θ

Compare the two values.


1

Japt, 26 bytes

Ëq'/
ËÎq. Ë°¤ù8ì¯Ug1,1Ãr¶

Try it

-3 bytes thanks to @Shaggy!

Input is an array with 2 elements [address, subnet]. Transpiled JS below:

// U: implicit input array
// split elements in U on the / and
// save back to U using a map function
U = U.m(function(D, E, F) {
  return D.q("/")
});
// map the result of the previous operation
// through another function
U.m(function(D, E, F) {
  return D
    // get the address portion of the / split
    // value and split again on .
    .g().q(".")
    // map each octet through another function
    .m(function(D, E, F) {
      // convert the octet to a base 2 string
      // left padded to a length of 8
      return (D++).s(2).ù(8)
    })
    // join the base 2 octets
    .q()
    // take the left bits of the joined octets
    // determined by subnet size
    .s(0, U.g(1, 1))
})
  // at this point, the intermediate result
  // contains 2 masked values, reduce
  // using === to check for equality
  .r("===")


Interesting - I didn't realize you could coerce a string to a number with ++.
dana

Yup, just like you can in JS. It's no use, though, if you need to resuse the original value later on, though, but it is handy on occasion.
Shaggy

The need for the comma in the g method is annoying me; can't figure out a way around it at all. At least not one that'll save you a byte.
Shaggy


0

C# (Visual C# Interactive Compiler), 134 bytes

a=>a.Select(x=>x.Split('.','/').Take(4).Aggregate(0L,(y,z)=>y<<8|int.Parse(z))>>32-int.Parse(a[1].Split('/')[1])).Distinct().Count()<2

Try it online!

LINQ statement that takes a 2-element string array as input in [address, subnet] format.

Each dotted quad is converted into 32 bits of a long using bit manipulation. The bits are right shifted by the subnet size and elements are compared for equality.

There were a couple of C# answers at the time that this answer was posted, but none that used pure bit manipulation.

// a: input array containing address and subnet
a=>a
  // iterate over input elements
  .Select(x=>x
    // split element on . and /
    .Split('.','/')
    // the subnet will have 5 elements,
    // we only want the parts before the /
    .Take(4)
    // use an aggregate function to convert dotted quad to 32 bits
    .Aggregate(0L,(y,z)=>y<<8|int.Parse(z))
    // shift bits of aggregate to the right
    >>
    // shift amount determined by subnet size
    32-int.Parse(a[1].Split('/')[1])
  )
  // test for equality by checking if number
  // of unique values is equal to 1
  .Distinct()
  .Count()<2

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