आईपी ​​एड्रेस या नहीं?

Question

आपका नेटवर्क स्कैनिंग टूल इनपुट के बारे में कष्टप्रद है, और यदि आप इसे IPv4 एड्रेस फीड करते हैं तो यह तुरंत क्रैश हो जाता है जिसमें अनुचित अक्षर हैं या ठीक से फॉर्मेट नहीं किया गया है।

IPv4 पता एक 32-बिट संख्यात्मक पता है, जिसे पीरियड्स द्वारा अलग किए गए चार नंबरों के रूप में लिखा गया है। प्रत्येक संख्या शून्य से 255 हो सकती है ।

हमें उन क्रैश से बचने के लिए इनपुट को पूर्व-मान्य करने के लिए एक उपकरण लिखने की आवश्यकता है, और हमारा विशिष्ट उपकरण picky है: एक मान्य प्रारूप ऐसा दिखेगा a.b.c.dजहां a, b, c और d:

• एक प्रमुख शून्य के0 साथ एक या एक प्राकृतिक संख्या हो सकती है ।
• 0 - 255 (समावेशी) के बीच होना चाहिए।
• चाहिए नहीं की तरह विशेष प्रतीक होने +, -, ,, और अन्य।
• दशमलव (बेस 10) होना चाहिए

इनपुट : एक स्ट्रिंग

आउटपुट : सत्य या गलत मूल्य (मनमाने मूल्य भी स्वीकार किए जाते हैं)

परीक्षण के मामले :

Input            |  Output  |  Reason
                 |          |
- 1.160.10.240   |  true    |
- 192.001.32.47  |  false   |  (leading zeros present)
- 1.2.3.         |  false   |  (only three digits)
- 1.2.3          |  false   |  (only three digits)
- 0.00.10.255    |  false   |  (leading zeros present)
- 1.2.$.4        |  false   |  (only three digits and a special symbol present)
- 255.160.0.34   |  true    |
- .1.1.1         |  false   |  (only three digits)
- 1..1.1.1       |  false   |  (more than three periods)
- 1.1.1.-0       |  false   |  (special symbol present)
- .1.1.+1        |  false   |  (special symbol present)
- 1 1 1 1        |  false   |  (no periods)
- 1              |  false   |  (only one digit)
- 10.300.4.0     |  false   |  (value over 255)
- 10.4F.10.99    |  false   |  (invalid characters)
- fruit loops    |  false   |  (umm...)
- 1.2.3.4.5      |  false   |  (too many periods/numbers)
- 0.0.0.0        |  true    |
- 0.0 0.0.       |  false   |  (periods misplaced)
- 1.23..4        |  false   |  (a typo of 1.2.3.4)
- 1:1:1:1:1:1:1:1|  false   |  (an IPv6 address, not IPv4)

यह कोड-गोल्फ है , इसलिए कम से कम बाइट्स जीतेंगे!

उपयोगकर्ताओं के लिए ध्यान दें - यदि आप कुछ और परीक्षण-मामलों को जोड़ना चाहते हैं, तो आपका स्वागत है (एक संपादन का सुझाव देकर)। लेकिन, कृपया सुनिश्चित करें कि परीक्षण-मामले खुद को दोहराते नहीं हैं! धन्यवाद

Comments

Testcases सुझाएँ: 1.1.1.1.1, 1.1.1.1., .1.1.1, 1..1.1, 1..1.1.1, 1.1.1.0, 1.1.1.-0, 1.1.1.+1, 1.1.1.1E1, 1.1.1.256, 1.1.1.0x1, 255.255.255.255, 0.0.0.0, 'or 1=1--, <empty string>, 1 1 1 1, 1,1,1,1।

— tsh

"1.2.3.4.5" (बहुत लंबी आईपी को हटाने के लिए) और "999.0.0.0" (बहुत बड़ी आईपी को हटाने के लिए) परीक्षण मामलों को जोड़ने का सुझाव दें।

— त्रिगुटर्नोमेट्री

संभवतः थोड़ा अचार, लेकिन आपको शायद "आईपी पते" के बजाय "आईपीवी 4 पतों" का उल्लेख करना चाहिए - या कम से कम, कहीं और उल्लेख करें कि आपको सिर्फ आईपीवी 4 पतों का मतलब है - अन्यथा 1234: 5678 :: 1 एक वैध पते का पता होना चाहिए (जबकि विवरण से यह स्पष्ट है कि इसका इरादा नहीं है :)

— psmears 15

@Criggie आधार वास्तव में सभी वास्तविक IP4 नियमों (जैसे आपके द्वारा उल्लिखित) की जांच नहीं है, यह सुनिश्चित करना है कि इनपुट स्ट्रिंग कुछ अन्य (संभवतः बुरी तरह से लिखे गए) ऐप को क्रैश नहीं करता है जो केवल बहुत विशिष्ट रूप में इनपुट की अनुमति देता है । इसके अलावा, हम एक चुनौती के नियमों को बदलने नहीं जा रहे हैं जिसमें पहले से ही 30+ उत्तर हैं।

— ब्रैड

@ क्रिगी वॉर्थ ने यह देखते हुए कि RFC ने घोषणा की कि "पते चार ओकटेट्स की निश्चित लंबाई हैं"। मुझे लगता है कि आपके द्वारा संदर्भित फ्रिंज मामले इस चुनौती से अधिक विशिष्ट हैं।

— पोक

Answer 1

X86_64 मशीन कोड: 18 16 बाइट्स

संपादित करें: यह उत्तर काफी काम नहीं करता है, जैसा कि

1. मैं inet_ptonमानक सी पुस्तकालयों से उपयोग कर रहा हूं , जिसका मतलब है कि मुझे बाहरी की जरूरत है। हालांकि मैंने अपनी बाइट की गिनती में बाहरी को शामिल नहीं किया।
2. मैंने वास्तविक पते के लिए लाल क्षेत्र का उपयोग किया था, लेकिन एक फ़ंक्शन को बुलाया जो लाल क्षेत्र का उपयोग कर सकता था। यह सौभाग्य से मेरी मशीन पर नहीं है, लेकिन कुछ अजीब मानक लाइब्रेरी बिल्ड इसका उपयोग कर सकते हैं जो अपरिभाषित व्यवहार का कारण बन सकते हैं।

और हाँ, पूरी तरह से बहुत पहले से ही लिखित समारोह द्वारा किया जा रहा है

वैसे भी, मुझे यही मिला है: 48 89 fe 6a 02 5f 48 8d 54 24 80 e9 00 00 00 00

सभा:

section .text
    extern inet_pton
    global ipIsValid

ipIsValid:
    mov rsi, rdi
    ;mov rdi, 2 ; change to 10 for ipv6
    push 2
    pop rdi ; thank you peter
    lea rdx, [rsp - 128]
    jmp inet_pton

स्पष्टीकरण:

देख लेना inet_pton(3)। यह एक स्ट्रिंग आईपी एड्रेस लेता है और इसे एक बफर में रखता है जिसका आप उपयोग कर सकते हैं struct sockaddr। यह 3 तर्क लेता है: पता परिवार ( AF_INET(आईपीवी 4), 2, या AF_INET6(आईपीवी 6), 10), आईपी पते की स्ट्रिंग, और आउटपुट के लिए एक सूचक। यह सफलता पर 1, अमान्य पते के लिए 0, या -1 के लिए है, जब पते का परिवार न तो है AF_INETया AF_INET6(जो कभी नहीं होगा क्योंकि मैं इसके लिए एक निरंतर गुजर रहा हूं)।

इसलिए मैं केवल दूसरे तर्क के लिए रजिस्टर में स्ट्रिंग को स्थानांतरित करता हूं, पहले रजिस्टर को 2 पर सेट करता हूं, और तीसरे रजिस्टर को रेड जोन (स्टैक पॉइंटर के नीचे 128 बाइट्स) पर सेट करता हूं क्योंकि मैं परिणाम की परवाह नहीं करता हूं। तो मैं बस jmpकरने के लिए inet_ptonऔर फोन करने वाले को वापस कर सकते हैं !

मैं आपके मामलों का परीक्षण करने के लिए इस त्वरित परीक्षण कार्यक्रम को तैयार करता हूं:

#include <stdio.h>
#include <arpa/inet.h>
#include <netinet/ip.h>

extern int ipIsValid(char *);

int main(){
    char *addresses[] = {
        "1.160.10.240",
        "192.001.32.47",
        "1.2.3.",
        "1.2.3",
        "0.00.10.255",
        "1.2.$.4",
        "255.160.0.34",
        ".1.1.1",
        "1..1.1.1",
        "1.1.1.-0",
        ".1.1.+1",
        "1 1 1 1",
        "1",
        "10.300.4.0",
        "10.4F.10.99",
        "fruit loops",
        "1.2.3.4.5",
        NULL
    };

    for(size_t i = 0; addresses[i] != NULL; ++i){
        printf("Address %s:\t%s\n", addresses[i],
            ipIsValid(addresses[i]) ? "true" : "false");
    }
    return 0;
}

साथ इकट्ठा nasm -felf64 assembly.asm, साथ संकलन करें gcc -no-pie test.c assembly.o, और आपको मिलेगा:

Address 1.160.10.240:   true
Address 192.001.32.47:  false
Address 1.2.3.: false
Address 1.2.3:  false
Address 0.00.10.255:    false
Address 1.2.$.4:    false
Address 255.160.0.34:   true
Address .1.1.1: false
Address 1..1.1.1:   false
Address 1.1.1.-0:   false
Address .1.1.+1:    false
Address 1 1 1 1:    false
Address 1:  false
Address 10.300.4.0: false
Address 10.4F.10.99:    false
Address fruit loops:    false
Address 1.2.3.4.5:  false

मैं इसे बहुत छोटा बना सकता था यदि कॉलर को पास AF_INETया AF_INET6फ़ंक्शन के लिए माना जाता था

Comments

मुझे अच्छा लगता है कि आपने ऐसा किया। और तथ्य यह है कि आप इसे उन लोगों को समझाते हैं जो इसे नहीं समझ सकते हैं (साथ ही परीक्षण कोड) और भी बेहतर है। जो यह कहने के लिए नहीं है कि मैं इसे asm में कर सकता था; अब तक कई साल बीत चुके हैं लेकिन मुझे याद है कि आपकी व्याख्या (और इसलिए प्रक्रिया) क्या कह रही है (क्या करती है) को देखने के लिए पर्याप्त है। अच्छा कार्य।

— प्रातः

e9 00 00 00 00a jmp near $+5, a नहीं है jmp inet_pton। यदि आप inet_pton

— ओपकोड

15 बाइट्स-

— टीआईओ

आपको उत्तर शीर्षक में बाहरी को शामिल करना चाहिए, क्योंकि कार्यक्रम को इसकी आवश्यकता है और यह सभी प्लेटफार्मों पर उपलब्ध नहीं है।

— 20

"बाइट रेडी, 2" -2 बाइट्स के लिए "पुश 2 / पॉप रडी" हो सकता है। यह भी ध्यान दें कि डिस्सैडफ़ॉर्म गलत है या कोड गलत है। यह या तो "Mov edi" है (rdi नहीं) या कोई उपसर्ग मिसिंग है।

— पीटर फेर्री

Answer 2

जावा (JDK) , 63 बाइट्स

s->("."+s).matches("(\\.(25[0-5]|(2[0-4]|1\\d|[1-9])?\\d)){4}")

इसे ऑनलाइन आज़माएं!

क्रेडिट

• केविन क्रूज़सेन के लिए धन्यवाद
• पहले से विफल मामले को दिखाने के लिए l4m2.1.1.1.1 ।

Comments

आप अनुगामी अर्ध-उपनिवेश निकालना भूल गए। ;) और मैं यह सत्यापित कर सकता हूं कि यह सभी परीक्षण मामलों के लिए काम करता है, जिसमें टिप्पणियों में शामिल हैं। देखूंगा कि क्या मैं गोल्फ के लिए कुछ चीजें देखता हूं।

— केविन क्रूज़सेन 10

विफल.1.2.3.4

— l4m2

क्या बूलियन का उपयोग करने की अनुमति दी जाती है, जब उसे 0/1 की आवश्यकता होती है?

— l4m2

@ l4m2 मूल प्रश्न में मान्य / अमान्य था। इसलिए मुझे लगता है कि यहाँ कोई भी सत्य / गलत मूल्य स्वीकार्य है।

— केविन क्रूज़सेन

Output: 0 or 1और जावा में कोई ऑटो बूल नहीं है

— l4m2

Answer 3

जावास्क्रिप्ट (Node.js) , 43 बाइट्स

x=>x.split`.`.map(t=>[t&255]==t&&[])==`,,,`

इसे ऑनलाइन आज़माएं!

जावास्क्रिप्ट (Node.js) , 46 बाइट्स

x=>x.split`.`.every(t=>k--&&[t&255]==t,k=4)*!k

इसे ऑनलाइन आज़माएं!

अर्नुल्ड के हिस्से का इस्तेमाल किया

जावास्क्रिप्ट (Node.js) , 54 53 51 बाइट्स

x=>x.split`.`.every(t=>k--*0+t<256&[~~t]==t,k=4)*!k

इसे ऑनलाइन आज़माएं!

के लिए -2B 0+t<256, पैट्रिक स्टीफ़ेंसेन से -1B, + बचने के इनपुट करने के लिए 1 बी1.1.1.1e-80

RegExp समाधान 58 54 बाइट्स

s=>/^((2(?!5?[6-9])|1|(?!0\d))\d\d?\.?\b){4}$/.test(s)

3 बाइट्स के लिए डेडकोड ​​धन्यवाद

Comments

मैंने कुछ परीक्षण मामलों को जोड़ा है!

— rv7

यह सत्य के लिए देता है 0.0.0.0। बाकी सब ठीक काम करने लगता है।

— केविन क्रूज़सेन

@ केविनक्रूजसेन 0.0.0.0यहाँ सच है। बस SQL ​​इंजेक्शन यहाँ क्यों है?

— l4m2

आह रुको, मैं चुनौती के विवरण में वाक्य की गलत व्याख्या करता हूं। 0.0.0.0वास्तव में सत्य है। यह मेरे जवाब को भी गोल्फ देगा .. (और एसक्यूएल इंजेक्शन से आपका क्या मतलब है

— ?:

@ l4m2 मैंने इसे इसलिए जोड़ा क्योंकि हमें कुछ ऐसे टेस्टकेस की ज़रूरत है जो आईपी एड्रेस की तरह भी न हों।

— tsh

Answer 4

PHP , 39 36 बाइट्स

<?=+!!filter_var($argv[1],275,5**9);

इसे ऑनलाइन आज़माएं!

275 स्थिरांक जैसा दिखता है FILTER_VALIDATE_IP

कंटिन्यू की जगह 5 ** 9 का उपयोग किया जा रहा है FILTER_FLAG_IPV4। यह पर्याप्त है, क्योंकि 5**9 & FILTER_FLAG_IPV4सत्य है, जो कि पृष्ठभूमि में PHP करता है, जैसा कि बेनोइट एस्नार्ड ने बताया है।

यहां, filter_varपहला तर्क लौटाता है, यदि यह वैध IPv4 पता है, या गलत है तो नहीं। इसके साथ +!!, हम चुनौती द्वारा अपेक्षित उत्पादन का उत्पादन करते हैं।

Comments

यहां 3 बाइट्स सेव 5**9करने के बजाय उपयोग करना 1048576: PHP &IPv4 / IPv6 झंडे का परीक्षण करने के लिए उपयोग करता है , इसलिए 1048576 और 2097151 के बीच कोई भी संख्या मान्य है।

— बेनोइट एस्नार्ड

मैं इसके जवाब में (मूल रूप से) मेरा उत्तर (मूल रूप से) मेरा उत्तर: codegolf.stackexchange.com/a/174470/14732 लिखता हूं, जो 2018-10-22 09: 17: 34UTC पर लिखा गया था, जबकि आपका 2018-10-22 09 को लिखा गया था: 21: 55UTC। यहां तक ​​कि अगर मैं @BenoitEsnard द्वारा दिए गए 1-बाइट ऑप्टिमाइज़ेशन को वापस करता हूं, तो मेरा उत्तर कार्यक्षमता में बिल्कुल आपके जैसा है।

— इस्माइल मिगुएल

मुझे माफी मांगनी होगी, मैंने आपका जवाब नहीं देखा, हालांकि जिस समय मैं इसकी रचना कर रहा था, इस सवाल पर PHP में कोई सबमिशन नहीं था (जैसा कि आपने कहा, समय का अंतर पांच मिनट से कम है)।

— ओक्टुपोल

मुझे पता है, और मैं इसे समझता हूं। मैंने अब सिर्फ तुम्हारा ध्यान किया। मैं वापस मेरा रोल कर सकता हूं, और आप ऑप्टिमाइजेशन को बनाए रखेंगे। लेकिन मुझे नहीं पता कि क्या यह उत्तर प्रत्येक अभिभावक से अलग है।

— इस्माइल मिगुएल

@IsmaelMiguel मैं किसी को इस बात के लिए नीचा नहीं दिखाऊंगा कि अगर यह आपके होने की संभावना नहीं है तो वे शुरू हो गए। 5 मिनट के अंतर के साथ, न केवल यह प्रशंसनीय है, यह लगभग निश्चित रूप से मामला है, जो लेखक के स्वयं के बिना भी स्पष्ट है।

— डंकन एक्स सिम्पसन

Answer 5

PHP, 36 बाइट्स

echo(ip2long($argv[1])===false?0:1);

ip2longएक प्रसिद्ध निर्मित कार्य है ।

Comments

29 बाइट्स

— nwellnhof 10

यह नए संस्करणों में मौजूद अनियोजित सुविधाओं का उपयोग करने के लिए लगता है (मुझे लगता है कि यह PHP7 + से है)। ध्यान रखें कि, PHP 4 और 5 के लिए, यह अधूरे IP को स्वीकार करता है।

— इस्माइल मिगुएल

27 बाइट्स

— मार्क

codegolf.meta.stackexchange.com/a/7146/12130

— डेविड मुल्डर

यह सफलता देगा यदि आप इसे किसी भी पूर्णांक, जैसे कि 1, 2, आदि को खिलाते हैं, तो यह मत सोचो कि यह चाहिए। और अगर आप इसे 100.100.100 के रूप में कुछ भी खिलाते हैं

— nl-x

Answer 6

पर्ल 6 , 22 21 20 बाइट्स

फिल एच को धन्यवाद।

{?/^@(^256)**4%\.$/}

इसे ऑनलाइन आज़माएं!

व्याख्या

{                  }  # Anonymous Block
  /               /   # Regex match
   ^             $    # Anchor to start/end
    @(    )           # Interpolate
      ^256            #   range 0..255,
                      #   effectively like (0|1|2|...|255)
           **4        # Repeated four times
              %\.     # Separated by dot
 ?                    # Convert match result to Bool

Comments

यार, मुझे पर्ल 6 के रेगीज़ के बारे में और अधिक समय बिताने की ज़रूरत है। मेरे पास कोई भी %संशोधक मौजूद नहीं था। मुझे आश्चर्य है कि अगर यह सभी 256**4संभावनाओं की जांच करने की कोशिश करता है?

— जो राजा

इसके बजाय <{^256}>आप सिर्फ @(^256)-1 char TIO के लिए रेंज को सरणी में बदल सकते हैं । कोड ब्लॉक को एक सरणी में बदलने से यह बहुत तेजी से (0.4 के बजाय 30) हो जाता है।

— फिल एच

@PHH कूल, धन्यवाद। मैंने कोशिश की $(^256)लेकिन अब मुझे एहसास हुआ कि यह काम क्यों नहीं किया।

— nwellnhof

Answer 7

05AB1E , 26 24 23 22 23 बाइट्स

'.¡©g4Q₅Ý®å`®1šDïþJsJQP

-1 बाइट @ इग्निना के लिए धन्यवाद ।
बगफुटिंग टेस्ट मामले के लिए +1 बाइट 1.1.1.1E1गलत तरीके से एक सत्य परिणाम लौटाता है।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

'.¡              '# Split the (implicit) input by "."
   ©              # Save it in the register (without popping)
    g4Q           # Check that there are exactly 4 numbers
    ₅Ý®å          # Check for each of the numbers that they are in the range [0,255],
        `         # and push the result for each number separated onto the stack
    ®1šDïþJsJQ    # Check that each number does NOT start with a "0" (excluding 0s itself),
                  # and that they consist of digits only
              P   # Check if all values on the stack are truthy (and output implicitly)

Comments

आप Āइसके बजाय का उपयोग करने में सक्षम होना चाहिए<d

— Emigna

@MagicOctopusUrn मुझे डर लग रहा है कि यह विफल रहता है के लिए 1.1.1.1E1, 1..1.1.1, 1.1.1.1., 192.00.0.255, और 0.00.10.255। (पुनश्च: मैंने जॉइन-एंड-समान चेक को 1.1.1.1E1जोड़कर तय किया है þ।)

— केविन क्रूज़सेन

काफी उचित, लगा कि मैं कुछ याद किया।

— मैजिक ऑक्टोपस Urn

@MagicOctopusUrn मुख्य मुद्दा 05AB1E है, जिसकी संख्या 0s के बराबर है, बिना स्ट्रिंग के भी। कारण है कि मैं का उपयोग कौन सा है DïþJsJQकी जांच जहां ïयह प्रमुख 0s को दूर करने के लिए int डाली, और þकेवल पत्ते अंक जैसी चीजों को हटाने E, -आदि :) 1šपरीक्षण मामले के लिए है 0.00.10.255, के बाद से 00010255और 0010255बराबर होगा।

— केविन क्रूजसेन

हाँ, मैं एक ही बकवास के माध्यम से चला गया, उन मामलों को छोड़कर, सभी नंबरों के उलट ने बहुत अच्छी तरह से काम किया। दिलचस्प जब कुछ समस्याओं के लिए फायदेमंद सुविधाएँ दूसरों के लिए लगभग बग-जैसी हो जाती हैं।

— मैजिक ऑक्टोपस Urn

Answer 8

पावरशेल, 59 51 49 बाइट्स

-8 बाइट्स, धन्यवाद @AdmBorkBork

-2 बाइट्स, trueया falseलेखक द्वारा अनुमति

try{"$args"-eq[IPAddress]::Parse($args)}catch{!1}

टेस्ट स्क्रिप्ट:

$f = {

try{"$args"-eq[IPAddress]::Parse($args)}catch{!1}

}

@(
    ,("1.160.10.240" , $true)
    ,("192.001.32.47" , $false)
    ,("1.2.3." , $false)
    ,("1.2.3" , $false)
    ,("0.00.10.255" , $false)
    ,("192.168.1.1" , $true)
    ,("1.2.$.4" , $false)
    ,("255.160.0.34" , $true)
    ,(".1.1.1" , $false)
    ,("1..1.1.1" , $false)
    ,("1.1.1.-0" , $false)
    ,("1.1.1.+1" , $false)
    ,("1 1 1 1" , $false)
    ,("1"            ,$false)
    ,("10.300.4.0"   ,$false)
    ,("10.4F.10.99"  ,$false)
    ,("fruit loops"  ,$false)
    ,("1.2.3.4.5"    ,$false)

) | % {
    $s,$expected = $_
    $result = &$f $s
    "$($result-eq$expected): $result : $s"
}

आउटपुट:

True: True : 1.160.10.240
True: False : 192.001.32.47
True: False : 1.2.3.
True: False : 1.2.3
True: False : 0.00.10.255
True: True : 192.168.1.1
True: False : 1.2.$.4
True: True : 255.160.0.34
True: False : .1.1.1
True: False : 1..1.1.1
True: False : 1.1.1.-0
True: False : 1.1.1.+1
True: False : 1 1 1 1
True: False : 1
True: False : 10.300.4.0
True: False : 10.4F.10.99
True: False : fruit loops
True: False : 1.2.3.4.5

स्पष्टीकरण:

.NET ऑब्जेक्ट, IPAddress का निर्माण करने के लिए स्क्रिप्ट एक तर्क स्ट्रिंग को पार्स करने की कोशिश करती है ।

• वापसी $trueकरता है, तो objectबनाया है और तर्क स्ट्रिंग के एक स्ट्रिंग प्रतिनिधित्व के बराबर है object(द्वारा सामान्यीकृत पता object.toString())
• $falseअन्यथा लौट आओ

PowerShell, 59 56 54 बाइट्स, 'एक .NET lib' विकल्प का उपयोग न करें

-3 बाइट्स, trueया falseलेखक द्वारा अनुमति

-2 बाइट्स, कूल रेगेक्सप के लिए @ डेडकोड ​​के लिए धन्यवाद ।

".$args"-match'^(\.(2(?!5?[6-9])|1|(?!0\B))\d\d?){4}$'

इसे ऑनलाइन आज़माएं!

मूल नियमित अभिव्यक्ति के लिए धन्यवाद @ ओलिवियर ग्रेजायर ।

Comments

आपको कॉल करने की आवश्यकता नहीं है |% t*gक्योंकि PowerShell स्वचालित रूप से राइट-साइड-साइड को -eqस्ट्रिंग के रूप में डालेगा, क्योंकि बाएं हाथ-साइड एक स्ट्रिंग है। -try{+("$args"-eq[IPAddress]::Parse($args))}catch{0}

— AdmBorkBork

आप मेरे रेगेक्स का उपयोग करके "बॉटम .NET एफिशिएंट" वर्जन से 2 बाइट्स को कैरी कर सकते हैं (इंसर्ट-इन-पीरियड ट्रिक के लिए अनुकूलित, जो मेरे वर्जन में नहीं हो सकता क्योंकि यह एक शुद्ध रेक्स है): tio.run/…

— डेडकोड

Answer 9

C (gcc) / POSIX, 26 बाइट्स

f(s){s=inet_pton(2,s,&s);}

इसे ऑनलाइन आज़माएं!

टीआईओ पर 64-बिट कोड के रूप में काम करता है, लेकिन संभवतः sizeof(int) == sizeof(char*)अन्य प्लेटफार्मों पर इसकी आवश्यकता होती है ।

Comments

@TobySpeight हाँ, यदि आप x86 पर हैं, तो आपको संभवतः 32-बिट मोड ( -m32) में प्रयास करना चाहिए ।

— nwellnhof

मुझे यह काम करने के लिए मिला, sएक char*(ILP32 सिस्टम तक पहुंच नहीं) के रूप में पास करके , और हां, मैं साथ मिला रहा था inet_aton()।

— टोबी स्पाईट

Answer 10

PHP 7+, 37 35 32 बाइट्स

यह अंतर्निहित फ़ंक्शन का उपयोग करता है filter_var, यह प्रमाणित करने के लिए कि यह एक आईपीवी 4 पता है ।

इसे काम करने के लिए, आपको iGET अनुरोध पर कुंजी को पास करना होगा ।

<?=filter_var($_GET[i],275,5**9);

परिणाम के आधार पर falsy(परिणाम के लिए) या आईपी (परिणाम के लिए) कुछ भी नहीं करेगा truthy।

आप इस पर कोशिश कर सकते हैं: http://sandbox.onlinephpfunctions.com/code/639c22281ea3ba753cf7431281486d8e6e66f68e http://sandbox.onlinephpfunctions.com/code/ff6aaeb2b2d0e0ac43f48125de0549320bc071b4

---

यह सीधे निम्नलिखित मानों का उपयोग करता है:

• 275 = FILTER_VALIDATE_IP
• 1 << 20 = 1048576 = FILTER_FLAG_IPV4
• 5 ** 9 = 1953125 (1048576 के लिए "1" के रूप में आवश्यक बिट है)

इस टिप के लिए बेनोइट एस्नर्ड को धन्यवाद जिसने मुझे 1 बाइट बचाकर रखा!

चुनौती के बदलाव की याद दिलाने के लिए टाइटस को धन्यवाद ।

---

मैंने फ़ंक्शन का उपयोग करने पर ध्यान दिया है ip2long, लेकिन यह गैर-पूर्ण आईपी पते के साथ काम करता है।

इस चुनौती में गैर-पूर्ण IPv4 पतों को अवैध माना जाता है।

यदि उन्हें अनुमति दी गई थी, तो यह अंतिम कोड होगा (केवल PHP 5.2.10 के लिए):

<?=ip2long($_GET[i]);

वर्तमान में, प्रलेखन में यह स्पष्ट नहीं है कि यह नए PHP संस्करणों के साथ काम करना बंद कर देगा (जब एक अपूर्ण आईपी पारित किया गया)।

परीक्षण के बाद, पुष्टि की कि मामला था।

टिप के लिए nwellnhof के लिए धन्यवाद !

Comments

यहां एक बाइट बचाने के 5**9बजाय उपयोग करना 1<<20: PHP का उपयोग करता है& IPv4 / IPv6 झंडे का परीक्षण करने के लिए है , इसलिए 1048576 और 2097151 के बीच कोई भी संख्या मान्य है।

— बेनोइट एस्नार्ड

नए PHP संस्करणों में, ip2long अधूरे पते की अनुमति नहीं देता है।

— nwellnhof

@BenoitEsnard धन्यवाद! मैंने इसे उत्तर में जोड़ दिया है

— इस्माइल मिगुएल

@nwellnhof परीक्षण के बाद, मैं पुष्टि करता हूं कि यह मामला है। हालाँकि, मुझे नहीं लगता कि इसका उपयोग करना एक अच्छा विचार है, क्योंकि यह स्पष्ट रूप से प्रलेखित नहीं है।

— इस्माइल मिगुएल

+!!आवश्यक नहीं; ओपी अब मनमानी सत्य मूल्यों को स्वीकार करता है।

— टाइटस

Answer 11

पायथन 3: 81 78 70 69 66 बाइट्स

['%d.%d.%d.%d'%(*x.to_bytes(4,'big'),)for x in range(16**8)].count

सभी संभावित IPv4 पते पर लूप करें, स्ट्रिंग प्रतिनिधित्व प्राप्त करें और इसे इनपुट से तुलना करें। यह उह ... चलने में थोड़ा समय लगता है।

संपादित करें: पूर्ण कार्यक्रम से अनाम फ़ंक्शन पर स्विच करके 3 बाइट्स निकाले।

EDIT2: Xnor की मदद से 8 बाइट्स निकाले

EDIT3: सूची बोध के बजाय अनपैक्ड मैप का उपयोग करके 1 बाइट को हटा दिया गया

EDIT4: ipaddressमॉड्यूल के बजाय सूची समझ का उपयोग करके 3 बाइट्स निकाले

Comments

मुझे लगता है कि आपका अनाम कार्य बस हो सकता है [str(ip_address(x))for x in range(256**4)].count। भी, 256**4हो सकता है 16**8।

— xnor

Answer 12

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 84 79 65 बाइट्स

s=>s.Split('.').Sum(t=>byte.TryParse(t,out var b)&t==b+""?1:5)==4

इसे ऑनलाइन आज़माएं!

-5 और -14 बाइट्स ने @ डाना को धन्यवाद दिया!

# सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 61 बाइट्स

s=>s.Count(c=>c==46)==3&IPAddress.TryParse(s,out IPAddress i)

इसे ऑनलाइन आज़माएं!

यह काम प्रगति पर है। कोड का उपयोग System.Net(+17 बाइट्स यदि आप इसे गिनते हैं)। अगर आपको आश्चर्य होता है कि मैं क्यों गिनता हूं और पार्स करता हूं:

IPAddress.TryParse पद्धति के साथ सीमा यह है कि यह सत्यापित करता है कि क्या स्ट्रिंग को IP पते में परिवर्तित किया जा सकता है, इस प्रकार यदि इसे "5" जैसे स्ट्रिंग मान के साथ आपूर्ति की जाती है, तो इसे "0.0.0.5" के रूप में माना जाता है।

स्रोत

जैसा कि @milk ने टिप्पणी में कहा, यह वास्तव में अग्रणी शून्य पर विफल रहेगा। तो, 61 बाइट्स एक काम नहीं कर रहा है।

Comments

@ दाना महान। अच्छी तरह से किया! चार और यह 61 बाइट्स समाधान को हरा देगा!

— aloisdg का कहना है कि मोनिका

Answer 13

पायथन 2 , 85 82 81 बाइट्स

केविन क्रूज़सेन के लिए धन्यवाद

from ipaddress import*
I=input()
try:r=I==str(IPv4Address(I))
except:r=0
print~~r

इसे ऑनलाइन आज़माएं!

113 बाइट उत्तर हटा दिया जाता है क्योंकि यह विफल रहता है1.1.1.1e-80

Comments

आप गोल्फ कर सकते हैं print 1*rकरने के लिए print~~r। +1 हालांकि, चूंकि यह इस प्रकार अब तक सुझाए गए सभी संभावित परीक्षण मामलों के लिए काम करता है । पुनश्च: आपका 113 बाइट उत्तर विफल रहता है 1.1.1.1e-80।

— केविन क्रूज़सेन

@ केविनक्रूजसेन धन्यवाद! संख्याओं के ऐसे अंकन के बारे में नहीं सोचा

— डेड पॉसम

नहीं है ipaddressएक अजगर 3 मॉड्यूल?

— फरहान।

@ फरहान। डनो, लेकिन यह TIO में काम करता है

— डेड

Answer 14

जाप, 17 15 बाइट्स

q.
ʶ4«Uk#ÿòs)Ê

इसे आज़माएं या सभी परीक्षण मामलों को चलाएं या चुनौती टिप्पणियों से अतिरिक्त परीक्षण मामलों को सत्यापित करें

---

व्याख्या

हम एक सरणी पर विभाजित करते हैं ., यह देखते हैं कि उस सरणी की लंबाई बराबर है 4और यह कि लंबाई जब सीमा में सभी तत्वों ["0","255"]को हटा दिया जाता है तो यह गलत है ( 0)।

                 :Implicit input of string U
q.               :Split on "."
\n               :Reassign resulting array to U
Ê                :Length of U
 ¶4              :Equals 4?
   «             :&&!
    Uk           :Remove from U
      #ÿ         :  255
        ò        :  Range [0,255]
         s       :  Convert each to a string
          )      :End removal
           Ê     :Length of resulting array

Comments

अच्छा जवाब। इस प्रकार अब तक सभी सुझाए गए परीक्षण मामलों के लिए भी सत्यापित किया गया है । उस स्पष्टीकरण को देखने के लिए उत्सुक।

— केविन क्रूज़सेन

@KevinCruijssen, स्पष्टीकरण जोड़ा गया। उन अतिरिक्त परीक्षण मामलों के लिए धन्यवाद।

— झबरा

Answer 15

मेथेमेटिका, ३ ९ ३१ बाइट्स

मूल संस्करण:

¬FailureQ[Interpreter["IPAddress"][#]]&

संशोधित संस्करण (मीशा लावरोव का धन्यवाद)

 AtomQ@*Interpreter["IPAddress"]

जो रिटर्न Trueअगर एक मान्य IP पता है ( यह कोशिश )।

यदि आप पाने के लिए जोर देते हैं 1और 0इसके बजाय, तो एक अतिरिक्त 7 बाइट्स आवश्यक होंगे:

Boole/@AtomQ@*Interpreter["IPAddress"]

Comments

चूंकि Interpreter["IPAddress"]वैध इनपुट के लिए एक स्ट्रिंग देता है, और अमान्य इनपुट के लिए कुछ जटिल विफलता वस्तु, हम वैध इनपुट के लिए परीक्षण कर सकते हैं AtomQ[Interpreter["IPAddress"][#]]&, जिसे फ़ंक्शन संरचना में और छोटा किया जा सकता है AtomQ@*Interpreter["IPAddress"]। इसे ऑनलाइन आज़माएं!

— मिशा लावरोव

जैसे IPv6 पते पर विफल रहता है 2001:0db8:85a3:0000:0000:8a2e:0370:7334।

— lirtosiast

Answer 16

जावास्क्रिप्ट (ईएस 6), 49 बाइट्स

एक बूलियन मान लौटाता है।

s=>[0,1,2,3].map(i=>s.split`.`[i]&255).join`.`==s

इसे ऑनलाइन आज़माएं!

Answer 17

पायथन 2, 93 89 67 53 बाइट्स

[i==`int(i)&255`for i in input().split('.')]!=[1]*4>_

इसे ऑनलाइन आज़माएं!

एक और शेविंग के लिए डेनिस को धन्यवादआंतरिक तुलना और निकास कोड पर 14 बाइट्स ।

22 बाइट्स शेविंग और एक लॉजिक फिक्स के लिए जोनाथन एलन को विशेष धन्यवाद! पेस्की कोशिश / छोड़कर भिखारी!

कच्चे बाइट्स के बजाय ठीक से स्वरूपित स्ट्रिंग्स लेना, 4 बाइट्स को बंद कर देता है, धन्यवाद जो किंग।

Comments

आपके चेक को गोल्फ किया जा सकता है i==`int(i)&255` । इसके अलावा, आप [...]!=[1]*4>_वैसे भी त्रुटि के लिए बाध्य कर सकते हैं , क्योंकि आप वैसे भी निकास कोड का उपयोग कर रहे हैं। इसे ऑनलाइन आज़माएं!

— डेनिस

@ डेनिस मुझे समझ नहीं आता कि क्या >_करता है। बिटवाइज़ और हालांकि काफी सरल है ... मैं खुद को उन लोगों के संयोजन में असफल रहा।

— टेम्पोरलवुल्फ़

यदि !=रिटर्न गलत, अजगर शॉर्ट-सर्किट और कुछ नहीं होता है; दुभाषिया सामान्य रूप से बाहर निकलता है। यदि यह सत्य है, तो >_NameError उठाता है, क्योंकि चर _अपरिभाषित है।

— डेनिस

आंकड़े I श्रृंखला की मेरे जवाब में तुलना करते हैं और फिर आपकी टिप्पणी में स्पष्ट परिणाम याद करते हैं। स्पष्टीकरण के लिए धन्यवाद।

— तैमूरलॉल्फ

Answer 18

sfk , 176 बाइट्स

* मूल रूप से बैश + एसएफके था लेकिन टीआईओ ने तब से एक उचित एसएफके आवरण जोड़ा है

xex -i "_[lstart][1.3 digits].[1.3 digits].[1.3 digits].[1.3 digits][lend]_[part2]\n[part4]\n[part6]\n[part8]_" +xed _[lstart]0[digit]_999_ +hex +linelen +filt -+1 -+2 +linelen

इसे ऑनलाइन आज़माएं!

Comments

पहले nc [addr] 1 -w1इसे छोटा करने से त्रुटि प्रिंटआउट की जाँच करेगा ?

@Rogem ncअग्रणी शून्य के साथ-साथ IPv6 पतों को भी स्वीकार करता है, इसलिए मुझे अभी भी उन को संभालना होगा - और यह sfkवैसे भी एक शेल उत्तर की तुलना में एक उत्तर के रूप में अधिक है।

— Οurous

Answer 19

python3 बैश * 60

* इसके अलावा अन्य गोले। कोई भी जिसके लिए एक प्रोग्राम से बाहर निकलने के कोड पर सत्य / झूठी परीक्षा पास होती है

read I
python3 -c "from ipaddress import*;IPv4Address('$I')"

व्याख्या

एक शुद्ध पायथन समाधान के साथ परेशानी यह है कि दुर्घटनाग्रस्त होने वाले एक कार्यक्रम को अनिश्चित माना जाता है। हम एक अपवाद का उपयोग "कोड" के एक उचित सत्य / fasly मान में अपवाद को परिवर्तित करने के लिए कर सकते हैं। हालाँकि, कुछ बिंदु पर पायथन इंटरप्रेटर इस बिना किसी अपवाद के हैंडल करता है और एक गैर-शून्य निकास कोड देता है। अपने पसंदीदा यूनिक्स शेल में भाषाओं को बदलने की कम-कम लागत के लिए, हम काफी कोड को बचा सकते हैं!

बेशक, यह इंजेक्शन हमलों के लिए कमजोर है ... इनपुट जैसे कि 1.1.1.1'); print('Doing Something Evilएक अनियंत्रित खतरा है!

Comments

( स्पष्टीकरण यह है (नहीं Explaination )।)

— पीटर मोर्टेनसेन

@PeterMortensen Yikes। यह लाल रंग में भी रेखांकित किया गया था। मेरे ब्राउज़र ने मुझे बचाने की कोशिश की, लेकिन मैं नहीं सुनूंगा। उस पकड़ने के लिए धन्यवाद!

— सोमपोम

पूर्ण कार्यक्रमों को निकास कोड के माध्यम से आउटपुट की अनुमति है, इसलिए यह 43 बाइट्स हो सकता है ।

— 16

@ बीएमओ दिलचस्प। यह बात बताने के लिए धन्यवाद! मुझे लगता है कि समस्या "सत्य / मिथ्या" से बदल गई है, क्योंकि मैं इसे पोस्ट करने के बाद से मनमाने ढंग से आउटपुट की अनुमति देता हूं, लेकिन मैं इससे पहले ध्यान नहीं दे पाया :)

— Sompom

Answer 20

ECMAScript शुद्ध रेगेक्स, 41 बाइट्स

^((2(?!5?[6-9])|1|(?!0\B))\d\d?\.?\b){4}$

इसे ऑनलाइन आज़माएं!
इसे regex101 पर आज़माएँ

मुझे लगता है कि इस रेगेक्स में तर्क खुद के लिए बोलता है, इसलिए मैं केवल सुंदर प्रिंट करूंगा, लेकिन यह टिप्पणी नहीं करूंगा:

^
(
    (
        2(?!5?[6-9])
    |
        1
    |
        (?!0\B)
    )
    \d\d?
    \.?\b
){4}
$

इसका उपयोग निम्नलिखित अन्य उत्तरों से 2 बाइट्स दाढ़ी बनाने के लिए किया जा सकता है:

• ओलिवियर ग्रेगोइरे (जावा (JDK))
• l4m2 (जावास्क्रिप्ट (Node.js))
• माज़ज़ी ( पॉवरशेल )
• केविन क्रूज़सेन (रेटिना)

यहां एक वैकल्पिक संस्करण है जो प्रमुख शून्य की अनुमति देता है, लेकिन लगातार ऐसा करता है (ओकटेट्स को अधिकतम 3 दशमलव अंकों द्वारा दर्शाया जा सकता है):

^((2(?!5?[6-9])|1|0?)\d\d?\.?\b){4}$

या किसी भी प्रमुख शून्य की अनुमति दें:

^(0*(2(?!5?[6-9])|1?)\d\d?\.?\b){4}$

Comments

\bऔर \B... यह स्मार्ट है!

— माज़ी

@ माज़ी हाँ, वे दो वास्तव में काम में आते हैं! मैं (?!0\d)इसके बजाय इस्तेमाल कर सकता था , लेकिन मुझे \Bबेहतर पसंद है!

— डेडकोड

PowerShell का उत्तर आपके regexp से छोटा नहीं होता है। मुझे माफ कर दो। किसी सरणी को स्ट्रिंग में बदलने के लिए उद्धरणों की आवश्यकता होती है। इसे ऑनलाइन आज़माएं!

— माज़ी

\.?\bमुझे भी मेरा उत्तर पर एक बाइट बचाया है, धन्यवाद!

— नील

सहेजे गए 3 बाइट्स thx

— l4m2

Answer 21

लाल , 106 बाइट्स

func[s][if error? try[t: load s][return off]if 4 <> length? t[return off]s =
form as-ipv4 t/1 t/2 t/3 t/4]

इसे ऑनलाइन आज़माएं!

पीछे हटना trueयाfalse

स्पष्टीकरण:

f: func [ s ] [
    if error? try [                  ; checks if the execution of the next block result in an error
        t: load s                    ; loading a string separated by '.' gives a tuple   
    ] [                              ; each part of which must be in the range 0..255
        return off                   ; if there's an error, return 'false' 
    ]
    if 4 <> length? t [              ; if the tuple doesn't have exactly 4 parts
        return off                   ; return 'false'  
    ]
    s = form as-ipv4 t/1 t/2 t/3 t/4 ; is the input equal to its parts converted to an IP adress
]

Answer 22

स्टेक्स , 14 बाइट्स

∞n·Θ3ª&JH‼∙*~Γ

इसे चलाएं और डीबग करें

अनपैक्ड, अनगुल्फेड और टिप्पणी की गई, यह इस तरह दिखता है।

VB      constant 256
r       [0 .. 255]
'|*     coerce and string-join with "|"; i.e. "0|1|2|3 ... 254|255"
:{      parenthesize to "(0|1|2|3 ... 254|255)"
]4*     make 4-length array of number pattern
.\.*    string join with "\\."; this forms the complete regex
|Q      is the input a complete match for the regex?

इसको चलाओ

Comments

यह जानकर आश्चर्य हुआ कि आपने भाषा को स्टैक्स बना दिया! यह अच्छा काम कर रहा है।

— rv7

धन्यवाद! गोल्फिंग भाषाओं का स्थान आश्चर्यजनक रूप से भीड़भाड़ वाला है, और मुझे यकीन नहीं है कि अगर स्टैक्स अपनी योग्यता के आधार पर अपने अस्तित्व को सही ठहरा सकता है, लेकिन मेरा मुख्य लक्ष्य सिर्फ यह देखना था कि क्या मैं ऐसा कर सकता हूं और शायद कुछ सीखूं। यह उम्मीद से अधिक मजेदार होने के लिए समाप्त हो गया।

— पुनरावर्ती

Answer 23

पायथन 3, 109 93 बाइट्स

import re
lambda x:bool(re.match(r'^((25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)(\.(?!$)|$)){4}$',x))

व्याख्या

प्रत्येक ओकटेट 0 - 255 हो सकता है:

• 25 से शुरू होता है और अंतिम अंक के रूप में 0-5 होता है
• 2 से शुरू करें, दूसरे नंबर के रूप में 0-4 है और अंत में कोई भी अंक है
• बाकी अंकों के रूप में 1, और 00 - 99 से शुरू होता है
• इसके केवल 2 अंक हैं - 1-9 पहले और उसके बाद कोई भी अंक है
• या सिर्फ एक अंक

एक ओकटेट एक (।) के साथ समाप्त हो सकता है या बस इस शर्त के साथ कि यह दोनों नहीं कर सकता है, नकारात्मक लुकहैड (?!$)इस मामले में लेता है

धन्यवाद @Zachary मुझे यह महसूस करने के लिए कि मैं रिक्त स्थान छोड़ सकता हूं (क्योंकि यह कोड गोल्फ है) सुधार के लिए
धन्यवाद @DLosc और मुझे अपनी गलती का एहसास कराने के लिए, अब इसे ठीक कर दिया गया है।

Comments

इसके लिए कुछ स्पष्टीकरण मदद कर सकते हैं।

— निसा

x: re.match=> x:re.match;, x=> ,x, और ) is=> )isको 3 बाइट्स बचाने चाहिए। इसके अलावा, रेगेक्स में, आप \dप्रत्येक की घटना के लिए उपयोग कर सकते हैं [0-9], और [1]=> 1। यह एक महान पहली पोस्ट की तरह लगता है, हालांकि!

— ज़ाचरी

[1-9][0-9]|[0-9]बन सकता है [1-9]\d|\d(प्रति Zacharý सलाह), जो बन सकता है [1-9]?\d। इसके अलावा, परीक्षण के बजाय re.match(...)is not None, आप कर सकते हैं bool(re.match(...))क्योंकि मैच ऑब्जेक्ट्स Noneसत्य हैं और गलत हैं। :)

— DLosc

हम्म। दरअसल, यह परीक्षण के मामले में विफल रहता है 1.2.3.4.5(और यह भी 1.2.3.4., जो परीक्षण मामलों की आधिकारिक सूची में नहीं है), क्योंकि यह चौथे नंबर के बाद एंड-ऑफ-स्ट्रिंग के बजाय एक अवधि से मेल खा सकता है।

— DL23 22'18

Answer 24

बैश , 30 बाइट्स

ipcalc -c `cat`;echo $(($?^1))

इसे ऑनलाइन आज़माएं!

Comments

echo $(($?))भाग की जरूरत नहीं है के बाद से कार्यक्रमों रहे हैं की अनुमति दी के लिए बाहर निकलें कोड के माध्यम से उत्पादन अपने परिणाम के लिए।

— ბიმო

Answer 25

चारकोल , 45 21 बाइट्स

Ｉ∧⁼№θ.³¬Φ⪪θ.¬№Ｅ²⁵⁶Ｉλι

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। संपादित करें: @ झबरा के जप उत्तर को पोर्ट करके 24 बाइट्स सहेजे गए। स्पष्टीकरण:

    θ                   Input string
   №                    Count occurrences of
     .                  Literal `.`
  ⁼                     Equal to
      ³                 Literal 3
 ∧                      Logical And
       ¬                Logical Not
          θ             Input string
         ⪪              Split on
           .            Literal `.`
        Φ               Filter by
            ¬           Logical Not
               ²⁵⁶      Literal 256
              Ｅ         Map over implicit range
                   λ    Map value
                  Ｉ     Cast to string
             №          Count occurrences of
                    ι   Filter value
Ｉ                       Cast to string
                        Implicitly print

Comments

नकारात्मक पूर्णांक जैसे 123.-50.0.12या के साथ परीक्षण मामलों के लिए विफल रहता है 1.1.1.-80। बाकी सब ठीक काम करने लगता है। इसलिए <256चेक in [0,255]इसके बजाय होना चाहिए ।

— केविन क्रूज़सेन

@ केविनक्रूजसेन वास्तव में अमान्य वर्णों को फ़िल्टर करने का कोड काम नहीं कर रहा था क्योंकि मैं आंतरिक लूप में परिवर्तनशील परिवर्तन को भूल गया था। अब तय होना चाहिए।

— नील

Answer 26

रेटिना , 46 44 बाइट्स

^
.
^(\.(25[0-5]|(2[0-4]|1\d|[1-9])?\d)){4}$

पोर्ट ऑफ @ ओलिवियरग्रेयर के जावा उत्तर , इसलिए उसे सुनिश्चित करना सुनिश्चित करें!
-2 बाइट्स @Neil की बदौलत ।

इसे ऑनलाइन आज़माएं ।

स्पष्टीकरण:

^
.                           # Prepend a dot "." before the (implicit) input
^...$                       # Check if the entire string matches the following regex
                            # exactly, resulting in 1/0 as truthy/falsey:
 (                          #  Open a capture group
  \.                        #   A dot "."
    (25[0-5]                #   Followed by a number in the range [250,255]
    |(2[0-4]|         ) \d) #   or by a number in the range [200,249]
    |(      |1\d|     ) \d) #   or by a number in the range [100,199]
    |(          |[1-9]) \d) #   or by a number in the range [10,99]
    |(                )?\d) #   or by a number in the range [0,9]
 )                          #  Close capture group
  {4}                       #  This capture group should match 4 times after each other

Comments

मेरा प्रयास (जो मैंने पोस्ट नहीं किया क्योंकि प्रश्न उस समय पकड़ में आया था) एक ही लंबाई थी, लेकिन \dसमूह अनुकूलन नहीं था , इसलिए आप दो बाइट्स बचा सकते हैं क्योंकि आपको Mविनिर्देश पर ज़रूरत नहीं है अंतिम पंक्ति।

— नील

मैं पर्ल 6 उत्तर को पोर्ट करके रेटिना को 42 बाइट्स तक नीचे लाने में कामयाब रहा, लेकिन यह उत्तर 0.8.2 में भी काम करता है जो मेरा पोर्ट नहीं करता है।

— नील

Answer 27

जेली , 11 बाइट्स

⁹ḶṾ€ṗ4j€”.ċ

पात्रों की एक सूची को स्वीकार करने वाला एक विचित्र लिंक जो पैदावार देता है $1$ यदि यह एक वैध पता है और $0$अन्यथा। सभी की एक सूची बनाता है$256^4=4294967296$ पते और उसके बाद इनपुट की घटनाओं की संख्या गिना जाता है।

यहाँ समान है @ इसे ऑनलाइन आज़माएं! वह उपयोग करता है$16$( ⁴) के बजाय$256$( ⁹), चूंकि विधि इतनी अक्षम है!

कैसे?

⁹ḶṾ€ṗ4j€”.ċ - Link: list of characters, S
⁹           - literal 256
 Ḷ          - lowered range = [0,1,2,...,254,255]
  Ṿ€        - unevaluate €ach = ['0','1',...,['2','5','4'],['2','5','5']]
    ṗ4      - 4th Cartesian power = ALL 256^4 lists of 4 of them
            -               (e.g.: ['0',['2','5','5'],'9',['1','0']])
        ”.  - literal '.' character
      j€    - join for €ach (e.g. ['0','.','2','5','5','.','9','.','1','0'] = "0.255.9.10")
          ċ - count occurrences of right (S) in left (that big list)

Comments

65,536 आईपी के साथ संस्करण 1.8 सेकंड क्यों लेता है? o_O

— डेनिस

Answer 28

रेटिना , 42 41 बाइट्स

~(K`

255*
["^(("|'|]")\.?\b){4}$"L$`
$.`

इसे ऑनलाइन आज़माएं! @ Nwellnhof's पर्ल 6 उत्तर के पिछले संस्करण के आधार पर, लेकिन \.?\b@ डेडकोड ​​के उत्तर से चाल चोरी करके 1 बाइट बचाई गई । स्पष्टीकरण:

K`

कार्य क्षेत्र साफ़ करें।

255*

255 वर्ण डालें।

["^(("|'|]")\.?\b){4}$"L$`
$.`

रेंज उत्पन्न करें। 0.55 |s के साथ अलग , उपसर्ग के साथ ^((, और प्रत्यय के साथ )\.?\b){4}$, इस प्रकार नियमित अभिव्यक्ति का निर्माण ^((0|1|...255)\.?\b){4}$।

~(

मूल्यांकन करें कि मूल इनपुट पर।

Answer 29

पिप , 25 16 बाइट्स

a~=X,256RL4J"\."

कमांड-लाइन तर्क के रूप में उम्मीदवार आईपी पते को लेता है। इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें

व्याख्या

रेगेक्स समाधान, अनिवार्य रूप से पुनरावर्ती के स्टैक्स उत्तर का एक बंदरगाह है ।

                  a is 1st cmdline arg (implicit)
    ,256          Range(256), i.e. [0 1 2 ... 255]
   X              To regex: creates a regex that matches any item from that list
                  i.e. essentially `(0|1|2|...|255)`
        RL4       Create a list with 4 copies of that regex
           J"\."  Join on this string
 ~=               Regex full-match
a                 against the input

Answer 30

जावास्क्रिप्ट, 89 बाइट्स

(_,r=`(${[...Array(256).keys()].join`|`})`)=>RegExp(`^${(r+'\\.').repeat(3)+r}$`).test(_)

इसे ऑनलाइन आज़माएं!

रेंज के लिए RegExpहोने वाली एक सरणी के अनुक्रमित से कैप्चर समूह बनाएँ और साथ में भाग लिया चरित्र ( ) दोहराया सरणी के साथ बंद करने के बाद दोहराया स्ट्रिंग, वापसी या इनपुट के परिणाम से मेल खाते के परिणाम के बाद ।length 2560-255|.^(0|1...|255)\.(0|1...|255)\.(0|1...|255)\.(0|1...|255)$3$truefalseRegExp.prototype.test()