প্রদত্ত পরিসরে কতটি আইপি ঠিকানা রয়েছে?

31

দ্বারা অনুপ্রাণিত ...

নেটওয়ার্কিং - প্রদত্ত পরিসরে কতগুলি আইপি ঠিকানা রয়েছে তা আমি কীভাবে কাজ করব?

একটি প্রোগ্রাম বা ফাংশন লিখুন যা ইনপুট হিসাবে দুটি স্ট্রিং নেয়, প্রতিটি আইপিভি 4 ঠিকানা হ'ল স্ট্যান্ডার্ড ডটেড নোটেশন এবং আউটপুটগুলিতে প্রকাশিত হয় বা দুটি আইপি অ্যাড্রেস ইনপুট সহ এই রেঞ্জের আওতাভুক্ত আইপি অ্যাড্রেসের সংখ্যা প্রদান করে।

  • আইপি ঠিকানার পার্স করার জন্য আপনার কোনও বাহ্যিক কোড, লাইব্রেরি বা পরিষেবা ব্যবহার করা উচিত নয়। (অন্যান্য স্ট্রিং প্রসেসিং স্ট্যান্ডার্ড লাইব্রেরি ফাংশন গ্রহণযোগ্য।)
  • সমস্ত 2 ^ 32 আইপি ঠিকানা সমান। সম্প্রচার, E শ্রেণি ইত্যাদিতে কোনও পার্থক্য করা হয় না
  • সাধারণ কোড-গল্ফ বিধি প্রযোজ্য।

উদাহরণ স্বরূপ:

"0.0.0.0","255.255.255.255" returns 4294967296.
"255.255.255.255","0.0.0.0" also returns 4294967296.
"1.2.3.4","1.2.3.4" returns 1.
"56.57.58.59","60.61.62.63" returns 67372037.
"1","2" is invalid input. Your code may do anything you like.
code-golf  string  counting 
— billpg
সূত্র
আমি এই প্রশ্নটি প্রোগ্রামারগুলিতে দেখেছি এবং কোড গল্ফ লোলটিতে এটি জিজ্ঞাসা করার বিষয়ে ভাবছিলাম।
— ক্রাঙ্কার
3
আমি ভেবেছিলাম মানক অনুসারে আইপি অ্যাড্রেসগুলি কী অসম্ভব তা সম্পর্কে এটি স্ট্যাকওভারফ্লো প্রশ্ন।
— মিং-টাং
8
আইপিভি 4 কি কিছুটা পাস নেই?
— উগোরেন

উত্তর:

20

গল্ফস্ক্রিপ্ট, 20 বাইট

~]7/${2%256base}/)\-

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

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

$ echo 0.0.0.0 255.255.255.255 | golfscript range.gs
4294967296
$ echo 255.255.255.255 0.0.0.0 | golfscript test.gs
4294967296
$ echo 1.2.3.4 1.2.3.4 | golfscript test.gs
1
$ echo 56.57.58.59 60.61.62.63 | golfscript test.gs
67372037

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

~]        # Evaluate and collect into an array.
          #
          # “.” duplicates, so for "5.6.7.8 1.2.3.4", this leaves
          # [ 5 5 6 6 7 7 8 1 1 2 2 3 3 4 ] on the stack.
          #
7/        # Split into chunks of length 7: [ [ 5 5 6 6 7 7 8 ] [ 1 1 2 2 3 3 4 ] ]
$         # Sort the array of arrays: [ [ 1 1 2 2 3 3 4 ] [ 5 5 6 6 7 7 8 ] ]
{         # For each array:
  2%      # Extract every second element. Example: [ 1 2 3 4 ]
  256base # Convert the IP into an integer by considering it a base 256 number.
}/        #
)         # Add 1 to the second integer.
\-        # Swap and subtract. Since the integers were sorted, the result is positive.
— ডেনিস
সূত্র
$এড়াতে খুব সুন্দর এবং দুর্দান্ত ব্যবহার abs।
— ক্রিস জেস্টার-ইয়ং
4
~]সত্যিই চালাক।
— প্রিমো
10

পাইথন 2 - 106

এটি এখানে দেখুন ।

def a():x=map(int,raw_input().split("."));return x[0]*2**24+x[1]*2**16+x[2]*2**8+x[3]
print abs(a()-a())+1

উদাহরণ ইনপুট

0.0.0.0
0.0.0.255

উদাহরণ আউটপুট

256

— Rainbolt
সূত্র
1
def a():return reduce(lambda c,d:c*256+d,map(int,raw_input().split(".")))অনেক খাটো
— মাইকেল এম।
5
@ মিশেল এই পরামর্শের জন্য ধন্যবাদ। আমি এটি কয়েক মিনিটের জন্য ব্যবহার করেছি, তারপরে তাকিয়ে ভাবলাম, "আমি এর 90% লিখিনি"। সুতরাং আমি এটি ঘুরিয়ে।
— রেইনবোল্ট
@Michael a=lambda:পরিবর্তে def a():return 6 অক্ষর সংরক্ষণ
— avall
@ রুশার এটি 107 টি অক্ষর, 106 নয়
— অ্যাভাল
1
@ ওয়াল: আমি ধরে নিয়েছি আপনি চূড়ান্ত এলএফ গণনা করছেন।
— ডেনিস
8

সিজেম - 15

{r'./256b}2*-z)

এটি http://cjam.aditsu.net/ এ চেষ্টা করুন

ধন্যবাদ ডেনিস, বাহ, আমি নিজের ভাষা থেকে কীভাবে সেরা পেতে পারি তা আমি জানি না: পি

— aditsu
সূত্র
আপনি নির্মূল করে দুই বাইট সংরক্ষণ করতে পারবেন :i( bব্যবহার করে এবং এক পূর্ণসংখ্যা কাস্ট করতে মনে হয়) {r...}2*পরিবর্তেqS/{...}/
— ডেনিস
6

খাঁটি বাশ, 66 বাইট

p()(printf %02x ${1//./ })
r=$[0x`p $1`-0x`p $2`]
echo $[1+${r/-}]

নোট:

  • pএকটি বিন্দুযুক্ত দশমিক আইপি ঠিকানা পাস করা একটি ফাংশন সংজ্ঞায়িত করে , এবং সেই ঠিকানার হেক্স উপস্থাপনাকে আউটপুট দেয়:
    • ${1//./ }একটি প্যারামিটার সম্প্রসারণ যা পরিবর্তিত আইপি ঠিকানার .সাথে প্রতিস্থাপন করেp()
    • printfবেশিরভাগ স্ব ব্যাখ্যামূলক হয়। যেহেতু কেবলমাত্র একটি ফর্ম্যাট স্পেসিফায়ার %02xএবং চারটি বাকী আরগ রয়েছে, তাই প্রতিটি বাকী আর্গের জন্য ফর্ম্যাট স্পেসিফায়ারটি পুনরায় ব্যবহার করা হবে, কার্যকরভাবে কার্যকরভাবে 4 টি অক্টেটের প্রতিটির জন্য 2 হেক্স সংখ্যার সাথে একত্রিত
  • $[]পাটিগণিতের বিস্তৃতি ঘটায়। আমরা একটি মৌলিক বিয়োগ করি, এবং ভেরিয়েবলকে বরাদ্দ করিr
  • ${r/-}একটি সম্ভাব্য -অক্ষর অপসারণের জন্য প্যারামিটার সম্প্রসারণ - কার্যকরভাবে অ্যাবস ()
  • পরিসীমা দিতে 1 + পরম পার্থক্য প্রদর্শন করুন।

আউটপুট:

$ ./iprangesize.sh 0.0.0.0 255.255.255.255
4294967296
$ ./iprangesize.sh 255.255.255.255 0.0.0.0
4294967296
$ ./iprangesize.sh 1.2.3.4 1.2.3.4
1
$ ./iprangesize.sh 56.57.58.59 60.61.62.63
67372037
$ ./iprangesize.sh 1 2
2
$
— ডিজিটাল ট্রমা
সূত্র
আমি সনাক্ত printfএবং echo। সেই অংশগুলি bashকি?
— ক্যালকুলেটরফলাইন
1
পুনঃটুইটগুলি
— পর্ব
6

পাইথন ২.7 - 96 91 90 87

একটি ফাংশন তৈরি।

f=lambda a:reduce(lambda x,y:x*256+int(y),a.split("."),0)
p=lambda a,b:abs(f(a)-f(b))+1

ব্যবহার: 

>>> p("1.2.3.4","1.2.3.5")
2

সম্পাদনা: ফাংশন int()থেকে অপ্রয়োজনীয় সরানো হয়েছে f। Isaacg ধন্যবাদ

সম্পাদনাLF 2: ফাইলের শেষে সরানো হয়েছে ( @ রাশারকে ধন্যবাদ ) এবং ইনিশিয়ালাইজারের map()ব্যয়ে অপসারণ করা হয়েছে reduce()(@ এনজেজকি 2 কে ধন্যবাদ)

— avall
সূত্র
1
এফ ফাংশনটির বাইরের দিকে কেন () প্রয়োজন?
— isaacg
1
ভাল। আমার কোনও ধারণা ছিল না: ডি
— অ্যাভল
মানচিত্রটি ব্যবহার করার পরিবর্তে ,0
— হ্রাসগুলিকে অন্তর্ভুক্ত
আমি সবেমাত্র এমন কিছু লিখেছি যা হ'ল প্রায় আপনার কোড, তাই এখনই জমা দেওয়ার বিষয়ে আমি বিরক্ত করব না। আসলে আমার তিনটি চরিত্র দীর্ঘ!
— danmcardle
5

গল্ফস্ক্রিপ্ট, 27 বাইট

' '/{'.'/{~}%256base}/-abs)

উদাহরণ:

$ echo 0.0.0.0 255.255.255.255 | ruby golfscript.rb iprange.gs
4294967296
$ echo 255.255.255.255 0.0.0.0 | ruby golfscript.rb iprange.gs
4294967296
$ echo 1.2.3.4 1.2.3.4 | ruby golfscript.rb iprange.gs
1
$ echo 56.57.58.59 60.61.62.63 | ruby golfscript.rb iprange.gs
67372037
— ক্রিস জেস্টার-ইয়ং
সূত্র
2
/পরিবর্তে ব্যবহার করে আপনি একটি চর সংরক্ষণ করতে পারেন %~।
— ডেনিস
4

কফিস্ক্রিপ্ট - 94, 92, 79, 72

I=(a)->a.split(".").reduce((x,y)->+y+x*256)
R=(a,b)->1+Math.abs I(b)-I a

আন-গল্ফড :

I = ( a ) ->
    return a.split( "." ).reduce( ( x, y ) -> +y + x * 256 )

R = ( a, b ) ->
    return 1 + Math.abs I( b ) - I( a )

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

function ip2long( ip_str )
{
    var parts = ip_str.split( "." );    
    return parts.reduce( function( x, y ) {
        return ( +y ) + x * 256; //Note: the unary '+' prefix operator casts the variable to an int without the need for parseInt()
    } );
}

function ip_range( ip1, ip2 )
{
    var ip1 = ip2long( ip1 );
    var ip2 = ip2long( ip2 );

    return 1 + Math.abs( ip2 - ip1 );
}

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

— টনি এলিস
সূত্র
1
আপনি ফাঁকা জায়গায় কিছু বন্ধনী প্রতিস্থাপন করে কিছু অক্ষর সংরক্ষণ করতে পারেন:I=(a)->n=0;a.split(".").forEach((x)->n<<=8;n+=parseInt x);n>>>0 R=(a,b)->1+Math.abs I(b)-I a
— রব ডব্লু
দেখে মনে হচ্ছে আপনি এতে প্রচুর জায়গা হারাচ্ছেন Math.abs, তবে আমি ছোট কিছু দিয়ে আসতে পারি না। (z>0)*z||-zআমি যে সেরাটি পেয়েছি তা হ'ল (একই দৈর্ঘ্যের, এবং এটিতে একটি একক-চর ইনপুট প্রয়োজন)। আপনি কি এর চেয়ে চালাক কিছু আছে?
— অ্যারন ডুফর
এই জাভাস্ক্রিপ্ট সংস্করণটি আমাকে সত্যিই সহায়তা করে ive এক ঘন্টার মতো এটি অনুসন্ধান করে। ধন্যবাদ!
— নোডেফেক্ট
4

ডিসি, 61 টি অক্ষর

?[dXIr^*rdXIr^*256*+r1~dXIr^*r256*+65536*+]dspxsalpxla-d*v1+p

আমি মনে করি এটি অত্যন্ত আশ্চর্যজনক যে এটি একেবারেই ডিসির সাথে সমাধান করা যেতে পারে কারণ তারে স্ট্রিংগুলি পার্স করার ক্ষমতা নেই। কৌতুকটি হল 192.168.123.185 স্ট্যাক হিসাবে যায়

.185
.123
192.168

এবং dXIr^*দশমিক পয়েন্টটি ঠিক যতগুলি ভগ্নাংশের সংখ্যা রয়েছে ঠিক তেমন স্থানান্তরিত করে এবং এটি .100 এর জন্যও কাজ করে।

$ echo 56.57.58.59 60.61.62.63 | dc -e '?[dXIr^*rdXIr^*256*+r1~dXIr^*r256*+65536*+]dspxsalpxla-d*v1+p'
67372037.00

আপনি যদি ইনপুটটি ইতিমধ্যে স্ট্যাকের উপরে রাখেন তবে একটি অক্ষর বিয়োগ করুন।

— জিওফ রেডি
সূত্র
4

পাওয়ারশেল - 112 108 92 78 বাইট

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

গল্ফড (পুরানো):

$a,$b=$args|%{$t='0x';$_-split'\.'|%{$t+="{0:X2}"-f[int]$_};[uint32]$t};1+[math]::abs($a-$b)

গল্ফড (নতুন)

$a,$b=$args|%{$t='0x';$_-split'\.'|%{$t+="{0:X2}"-f+$_};[long]$t}|sort;1+$b-$a

Ungolfed:

$a, $b = $args | % {           #powershell's way of popping an array. In a larger array
                               #$a would equal the first member and $b would be the rest.
    $t = '0x';                 #string prefix of 0x for hex notation
    $_ -split '\.' | % {       #split by escaped period (unary split uses regex)
        $t += "{0:X2}" -f +$_  #convert a dirty casted int into a hex value (1 octet)
    };
    [long]$t                   #and then cast to long
} | sort;                      #sort to avoid needing absolute value
1 + $b - $a                    #perform the calculation

ব্যবহার

ফাইল হিসাবে সংরক্ষণ করুন (এই ক্ষেত্রে getipamount.ps1) এবং তারপরে কনসোল থেকে কল করুন

getipamount.ps1 255.255.255.255 0.0.0.0
— SomeShinyMonica
সূত্র
4

লিংক - ১৩৯ বাইট সহ সি #

(বব এর পরামর্শ প্রয়োগের পরে 140 থেকে।)

long f(params string[] a){return Math.Abs(a.Select(b=>b.Split('.').Select(long.Parse).Aggregate((c,d)=>c*256+d)).Aggregate((e,f)=>e-f))+1;}

Ungolfed ....

    long f(params string[] a)                           // params is shorter than two parameters.
    {
        return Math.Abs(                                // At the end, make all values +ve.
             a.Select(                                  // Go through both items in the array...
                b =>                                    // Calling each one 'b'. 
                    b.Split('.')                        // Separating out each "." separated byte...
                    .Select(long.Parse)                 // Converting them to a long.
                    .Aggregate((c, d) => c*256 + d)     // Shift each byte along and add the next one.
             )
             .Aggregate((e,f) => e-f)                   // Find the difference between the two remaining values.
         )+1;                                           // Add one to the result of Math.Abs.
    }

https://dotnetfiddle.net/XPTDlt

— billpg
সূত্র
কেউ আমাকে কীভাবে ব্যাখ্যা করতে পারেন যে কীভাবে এই পুরো শিফটিং বাইটগুলি কাজ করে?
— বিপর্যয়
@Obversity a.b.c.dসমতূল্য (a << 24) | (b << 16) | (c << 8) | (d << 0)সমতূল্য (((a << 8) << 8) << 8) + ((b << 8) << 8) + (c << 8) + d)। মূলত, সমষ্টিটির প্রতিটি পুনরাবৃত্তি বিদ্যমান যোগফল গ্রহণ করে এবং এটি একটি অক্টেটের মাধ্যমে রেখে যায়, তারপরে পরবর্তী অক্টেট যুক্ত করে
— বব
c*256পরিবর্তে ব্যবহার করে আপনি একটি অক্ষর সংরক্ষণ করতে পারেন (c<<8)।
— বব
পছন্দ করেছেন
— বিলপিজ
আপনি প্রতিস্থাপন এবং বাদ e-fদিয়ে আরও দুটি চরিত্র সংরক্ষণ করতে পারেনe<f?f-e:e-fMath.Abs()
— প্যাট্রিক হুইজিংসা
4

পার্ল, 43 বাইট

#!perl -pa
$_=1+abs${\map{$_=vec eval,0,32}@F}-$F[0]

শেবাংকে দুটি বাইট হিসাবে গণনা করা হচ্ছে।

নমুনা ব্যবহার:

$ echo 0.0.0.0 255.255.255.255 | perl count-ips.pl
4294967296

$ echo 255.255.255.255 0.0.0.0 | perl count-ips.pl
4294967296

$ echo 56.57.58.59 60.61.62.63 | perl count-ips.pl
67372037

নোট

  • vec eval,0,32একটি ড্রপ ইন জন্য ip2long। পার্ল চরিত্রের অক্ষরগুলিকে একটির সাথে পূর্বরূপযুক্ত হিসাবে তার অক্ষরকে প্রকাশ করার অনুমতি দেয় v, উদাহরণস্বরূপ v0নাল চরের জন্য ব্যবহার করা যেতে পারে। এগুলিও একসাথে বেঁধে রাখা যায়, উদাহরণস্বরূপ v65.66.67.68→ ABCD। তিন বা ততোধিক মান উপস্থিত থাকলে প্রাথমিকটি vঅপ্রয়োজনীয়। vecফাংশন ব্যাখ্যা করে একটি পূর্ণসংখ্যা অ্যারে হিসাবে একটি স্ট্রিং, প্রতিটি কক্ষে বিট নির্দিষ্ট নম্বর (এখানে 32) হচ্ছে। unpack N,evalপাশাপাশি সমানভাবে কাজ করতে হবে।
— Primo
সূত্র
3

জাভাস্ক্রিপ্ট ES6 - 68 বাইট

f=x=>prompt().split('.').reduce((a,b)=>+b+a*256);1+Math.abs(f()-f())

ফায়ারফক্সের কনসোল (এফ 12 টিপুন) দিয়ে এটি ব্যবহার করে দেখুন।

— মাইকেল এম।
সূত্র
আপনার ব্যবহার করা উচিত alertবা console.log। কনসোল আউটপুট সস্তা।
— nderscore
4
@ আন্ডারস্কোর, console.logসরাসরি আউটপুট এবং এর মধ্যে কোনও পার্থক্য নেই । এটি কোড-গল্ফ, এটি ক্লিন কোড করার বিষয়ে নয়।
— মাইকেল এম।
এই মেটা পোস্টের সর্বাধিক উত্সাহিত উত্তর একমত নয়: আইওয়ের জন্য জাভাস্ক্রিপ্ট স্ট্যান্ডার্ড । এটি পরিষ্কার কোডের বিষয় নয়। এটি আসলে কিছুই আউটপুট না করার বিষয়।
— nderscore
@ ডিজিটাল ট্রামুমা, এটি অপারেটর অগ্রাধিকারের কারণে কাজ করবে না । (অতিরিক্ত বনাম বিটওয়াস শিফট)
— মাইকেল এম।
2

পাইথন 2.7, 104 বাইট

y=lambda:map(int,input().split("."));a,b=y(),y();print sum(256**(3-i)*abs(a[i]-b[i])for i in range(4))+1
— পাবলো লুচেনা
সূত্র
1
সমাধানের জন্য ধন্যবাদ। আপনি কি মনে করেন যে আপনি করতে পারেন: 1. দৈর্ঘ্য ত্যাগ ছাড়াই পাঠ্যতার জন্য সেমিকোলন থেকে নতুন লাইনে স্যুইচ করুন। 2. কোডটি কীভাবে কাজ করে তা ব্যাখ্যা করুন?
— isaacg
2

পার্ল, 72 বাইট

#!perl -ap
@a=map{unpack N,pack C4,split/\./,$_}@F;$_=abs($a[1]-$a[0])+1

ব্যবহার:

$ echo 10.0.2.0 10.0.3.255 | perl ip-range.pl
512$

এটি প্রিমোর পার্ল প্রোগ্রামের চেয়ে ইতিমধ্যে দীর্ঘ , তাই খুব আকর্ষণীয় নয়।

অপ্রচলিত আইপি ঠিকানা বিন্যাসের জন্য পার্ল, ১১৯ বাইট

#!perl -ap
sub v(){/^0/?oct:$_}@a=map{$m=3;@p=split/\./,$_;$_=pop@p;$s=v;$s+=v<<8*$m--for@p;$s}@F;$_=abs($a[1]-$a[0])+1

ব্যবহার:

$ echo 10.0.2.0 10.0.3.255 | perl ip-obsolete.pl
512$ 
$ echo 10.512 10.1023 | perl ip-obsolete.pl
512$ 
$ echo 0xa.0x200 012.01777 | perl ip-obsolete.pl 
512$

এই প্রোগ্রামটি আইপি অ্যাড্রেসগুলির জন্য অপ্রচলিত ফর্ম্যাটটি গ্রহণ করে! এর মধ্যে 1, 2, বা 3 অংশ, বা হেক্সাডেসিমাল বা অষ্টাল অংশযুক্ত ঠিকানা অন্তর্ভুক্ত রয়েছে। Inet_addr (3) ম্যানুয়াল পৃষ্ঠাটি উদ্ধৃত করা হচ্ছে ,

ডট স্বরলিপি ব্যবহার করে নির্দিষ্ট মানগুলি নিম্নলিখিত ফর্মগুলির একটি গ্রহণ করে:

a.b.c.d
a.b.c
a.b
a

... যখন তিন অংশের ঠিকানা নির্দিষ্ট করা থাকে, শেষ অংশটি 16-বিট পরিমাণ হিসাবে ব্যাখ্যা করা হয় এবং নেটওয়ার্ক ঠিকানার ডানদিকের দুটি বাইটে স্থাপন করা হয়। ... যখন একটি দুই অংশের ঠিকানা সরবরাহ করা হয়, শেষ অংশটি 24-বিট পরিমাণ হিসাবে ব্যাখ্যা করা হয় এবং নেটওয়ার্কের ঠিকানার ডানদিকের তিনটি বাইটে স্থাপন করা হয়। ... যখন কেবল একটি অংশ দেওয়া হয়, মানটি কোনও বাইট পুনর্বিন্যাস ছাড়াই সরাসরি নেটওয়ার্ক ঠিকানায় সংরক্ষণ করা হয়।

ডট নোটেশনে `` যন্ত্রাংশ '' হিসাবে সরবরাহিত সমস্ত সংখ্যার দশমিক, অষ্টাল বা হেক্সাডেসিমাল হতে পারে, সি ভাষায় উল্লিখিত (যেমন, একটি শীর্ষস্থানীয় 0x বা 0 এক্স বোঝায় হেক্সাডেসিমেল; একটি শীর্ষস্থানীয় 0 ইঙ্গিত করে; অন্যথায়, সংখ্যাটি হ'ল দশমিক হিসাবে ব্যাখ্যা)।

বেশিরভাগ প্রোগ্রামগুলি এই অপ্রচলিত ফর্ম্যাটটি আর গ্রহণ করে না, ping 0177.1তবুও ওপেনবিএসডি 5.5 এ কাজ করেছে।

— kernigh
সূত্র
আপনি বিএসডি ব্যবহার করছেন তা আইপি জিনিসটির চেয়ে অবাক করা।
— পর্ব
2

পিএইচপি, 138 110 বাইট

<?php

function d($a,$b){foreach(explode('.',"$a.$b")as$i=>$v){$r+=$v*(1<<24-$i%4*8)*($i<4?1:-1);}return 1+abs($r);}

// use it as
d('0.0.0.0','255.255.255.255');
— ভাইটালি দ্যাতলভ
সূত্র
'না থামিয়ে দেওয়া সতর্কবার্তা' কোনো উল্লেখ নেই হিসাবে, আপনি প্রতিস্থাপন করে গৃহস্থালির কাজ সংরক্ষণ করতে পারবেন explode('.',"$a.$b")সঙ্গে split('\.',"$a.$b")।
— মিঃলরে
আমি 109 গণনা করছি, 110 নয়। এই গল্ফিং পদক্ষেপের সাথে একটি ফাংশনের পরিবর্তে 9 টি বাইট সংরক্ষণ করুন এবং আরও 8 টি: স্যান্ডবক্স.অনলাইনপ্পফিউশনস কোড
— টিটাস
1

গণিত 9, 108 বাইট

c[f_,s_]:=1+First@Total@MapIndexed[#1*256^(4-#2)&,First@Abs@Differences@ToExpression@StringSplit[{f,s},"."]]

Ungolfed:

countIpAddresses[first_, second_] := Module[{digitArrays, differences},

  (* Split the strings and parse them into numbers. 
  Mathematica automatically maps many/most of its functions across/
  through lists *)

  digitArrays = ToExpression[StringSplit[{first, second}, "."]];

  (* Find the absolute value of the differences of the two lists, 
  element-wise *)
  differences = Abs[Differences[digitArrays]];

  (* differences looks like {{4, 4, 4, 4}} right now, 
  so take the first element *)
  differences = First[differences];

  (* now map a function across the differences, 
  taking the nth element (in code, '#2') which we will call x (in 
  code, '#1') and setting it to be equal to (x * 256^(4-n)). 
  To do this we need to track the index, so we use MapIndexed. 
  Which is a shame, 
  because Map can be written '/@' and is generally a huge character-
  saver. *)
  powersOf256 = MapIndexed[#1*256^(4 - #2) &, differences];

  (* now we essentially have a list (of singleton lists, 
  due to MapIndexed quirk) which represents the digits of a base-256, 
  converted to decimal form. 
  Example: {{67108864},{262144},{1024},{4}}

  We add them all up using Total, 
  which will give us a nested list as such: {67372036}

  We need to add 1 to this result no matter what. But also, 
  to be fair to the challenge, we want to return a number - 
  not a list containing one number. 
  So we take the First element of our result. If we did not do this, 
  we could chop off 6 characters from our code. *)

  1 + First[Total[powersOf256]]
]
— আয়ান ডগলাস
সূত্র
0

সি # - 135

long f(string x,string y){Func<string,long>b=s=>s.Split('.').Select((c,i)=>long.Parse(c)<<(3-i)*8).Sum();return Math.Abs(b(x)-b(y))+1;}

সঠিকভাবে ফর্ম্যাট করা

long g(string x, string y) { 
    Func<string, long> b = s => s.Split('.').Select((c, i) => long.Parse(c) << (3 - i) * 8).Sum(); 
    return Math.Abs(b(x) - b(y)) + 1; 
}

https://dotnetfiddle.net/Q0jkdA

— টিয়া
সূত্র
0

রুবি, 93 বাইট

a=->(x){s=i=0;x.split('.').map{|p|s+=256**(3-i)*p.to_i;i+=1};s}
s=->(x,y){1+(a[x]-a[y]).abs}

আউটপুট

irb(main):003:0> s['1.1.1.1', '1.1.1.2']
=> 2
irb(main):006:0> s['0.0.0.0', '255.255.255.255']
=> 4294967296
— BSD
সূত্র
0

জে, 25 বাইট

ডটেড-কোয়াড আইপি স্ট্রিংগুলি বাম এবং ডান আর্গুমেন্ট হিসাবে নেয়।

>:@|@-&(256#.".;.2@,&'.')

ব্যাখ্যা:

>:@|@-&(256#.".;.2@,&'.')  NB. ip range
      &(                )  NB. on both args, do:
                   ,&'.'   NB.   append a .
               ;.2@        NB.   split by last character:
             ".            NB.     convert each split to number
        256#.              NB. convert from base 256
   |@-                     NB. absolute difference
>:@                        NB. add 1 to make range inclusive

উদাহরণ:

   '0.0.0.0' >:@|@-&(256#.".;.2@,&'.') '255.255.255.255'
4294967296
   iprange =: >:@|@-&(256#.".;.2@,&'.')
   '255.255.255.255' iprange '0.0.0.0'
4294967296
   '1.2.3.4' iprange '1.2.3.4'
1
   '56.57.58.59' iprange '60.61.62.63'
67372037
— algorithmshark
সূত্র
0

ফ্যাক্টর, 73 বাইট

কফিস্ক্রিপ্ট উত্তরের অনুবাদ।

[ "." split [ 10 base> ] [ [ 256 * ] dip + ] map-reduce ] bi@ - abs 1 + ]
— বিড়াল
সূত্র
0

জাভাস্ক্রিপ্ট ES6, 81 টি অক্ষর

(a,b)=>Math.abs(eval(`(((((${a})>>>0)-(((((${b})>>>0)`.replace(/\./g,")<<8|")))+1

টেস্ট:

f=(a,b)=>Math.abs(eval(`(((((${a})>>>0)-(((((${b})>>>0)`.replace(/\./g,")<<8|")))+1
;`0.0.0.0,255.255.255.255,4294967296
255.255.255.255,0.0.0.0,4294967296
1.2.3.4,1.2.3.4,1
56.57.58.59,60.61.62.63,67372037`.split`
`.map(x=>x.split`,`).every(x=>f(x[0],x[1])==x[2])

পিএস: আমি এটি আরও পরে অপ্টিমাইজ করার চেষ্টা করব।

— Qwertiy
সূত্র
0

লুয়া, 153 বাইট

এটি লজ্জার বিষয় যে লুয়ার একটি বিভক্ত ফাংশন নেই, আমাকে আমার সংজ্ঞা দিতে হয়েছিল!

a,b=...r=0y=8^8x={}t={}function f(t,s)s:gsub("%d+",function(d)t[#t+1]=d end)end
f(x,a)f(t,b)for i=1,4 do r=r+y*math.abs(t[i]-x[i])y=y/256 end print(r+1)

Ungolfed

a,b=...                    -- unpack the arguments into two variables
r=0                        -- initialise the sume of ip adress
y=8^8                      -- weight for the rightmost value
x={}t={}                   -- two empty arrays -> will contains the splittedip adresses
function f(t,s)            -- define a split function that takes:
                           --   a pointer to an array
                           --   a string
  s:gsub("%d+",function(d) -- iterate over the group of digits in the string
    t[#t+1]=d              -- and insert them into the array
  end)
end
f(x,a)                     -- fill the array x with the first address
f(t,b)                     -- fill the array t with the second address
for i=1,4                  -- iterate over t and x
do
  r=r+y*math.abs(t[i]-x[i])-- incr r by weight*abs(range a- range b)
  y=y/256                  -- reduce the weight
end
print(r+1)                 -- output the result
— Katenkyo
সূত্র
0

জেলি , 12 বাইট, ভাষা পোস্টডেটস চ্যালেঞ্জ

ṣ”.V€ḅ⁹µ€ạ/‘

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

ব্যাখ্যা

ṣ”.V€ḅ⁹µ€ạ/‘
       µ€     On each element of input:
ṣ”.             Split on periods
   V€           Convert string to number in each section
     ḅ⁹         Convert base 256 to integer
         ạ/   Take absolute difference of the resulting integers
           ‘  Increment

একটি অন্তর্ভুক্ত পরিসরে উপাদানের সংখ্যা হ'ল তাদের শেষ বিন্দুগুলির সম্পূর্ণ পার্থক্য, এবং আরও 1।

0

অ্যাক্সিয়াম, 385 বাইট

c(a:String):INT==(d:=digit();s:NNI:=#a;t:INT:=0;for i in 1..s repeat(~member?(a.i,d)=>return-1;t:=t+(ord(a.i)-48)*10^(s-i)::NNI);t)
g(x:String):List NNI==(a:=split(x,char".");s:NNI:=#a;r:=[];for i in s..1 by -1 repeat(y:=c(a.i);y=-1=>return [];r:=concat(y,r));r)
m(x:NNI,y:NNI):NNI==x*256+y
f(a:String,b:String):INT==(x:=g(a);y:=g(b);#x~=4 or #y~=4=>-1;1+abs(reduce(m,x)-reduce(m,y)))

এটি পরীক্ষা এবং পরীক্ষা

-- convert the string only digit a in one not negative number
-- return -1 in case of error
cc(a:String):INT==
     d:=digit();s:NNI:=#a;t:INT:=0
     for i in 1..s repeat
               ~member?(a.i,d)=>return -1
               t:=t+(ord(a.i)-48)*10^(s-i)::NNI
     t

-- Split the string x using '.' as divisor in a list of NNI
-- if error return []
gg(x:String):List NNI==
    a:=split(x,char".");s:NNI:=#a;r:=[]
    for i in s..1 by -1 repeat
          y:=cc(a.i)
          y=-1=>return []
          r:=concat(y,r)
    r


mm(x:NNI,y:NNI):NNI==x*256+y

-- Return absolute value of difference of address for IP strings in a and in b 
-- Retrun -1 for error
-- [Convert the IP strings in a and in b in numbers ad subtract and return the difference]
ff(a:String,b:String):INT==(x:=gg(a);y:=gg(b);#x~=4 or #y~=4=>-1;1+abs(reduce(mm,x)-reduce(mm,y)))


(14) -> f("0.0.0.0", "255.255.255.255")
   (14)  4294967296
                                                    Type: PositiveInteger
(15) -> f("255.255.255.255", "0.0.0.0")
   (15)  4294967296
                                                    Type: PositiveInteger
(16) -> f("1.2.3.4", "1.2.3.4")
   (16)  1
                                                    Type: PositiveInteger
(17) -> f("56.57.58.59", "60.61.62.63")
   (17)  67372037
                                                    Type: PositiveInteger
(18) -> f("1", "2")
   (18)  - 1
                                                            Type: Integer
— RosLuP
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.