17

एक आईपी पते को पूर्णांक प्रतिनिधित्व में बदलने के लिए सबसे छोटा फ़ंक्शन लिखें और इसे पूर्णांक के रूप में आउटपुट करें।

IPv4 पते को पूर्णांक प्रतिनिधित्व में बदलने के लिए, निम्नलिखित गणना आवश्यक है:

IP एड्रेस को चार ऑक्टेट में तोड़ें।
(Octet1 * 16777216) + (Octet2 * 65536) + (Octet3 * 256) + (Octet4)

नमूना इनपुट

192.168.1.1           10.10.104.36           8.8.8.8

नमूना आउटपुट

3232235777            168454180              134744072

code-golf conversion

— काइल रोजेंडो
स्रोत

2

मुझे लगता है कि यह बेहतर होगा यदि भाषा के अंतर्निहित कार्यों को प्रतिबंधित करने के स्थान पर प्रतिबंध था।

— नाथन उस्मान

@ जॉर्ज - हाँ, यह होता, लेकिन इससे पहले कि मैं इसे लगा सकता हूं - लोग ईमानदारी से इसके बारे में नहीं सोचते थे।

— काइल रोज़ेंडो

11

PHP - 21 वर्ण

<?=ip2long($argv[1]);

— ircmaxell
स्रोत

8

MySQL - 20 वर्ण

SELECT INET_ATON(s);

— ircmaxell
स्रोत

8

रूबी (कोई निर्माण / निकासी नहीं) - 47

s=->s{s.split(".").inject(0){|a,b|a<<8|b.to_i}}

परीक्षा:

s["192.168.1.1"]
3232235777

— अरनौद ले ब्लांक
स्रोत

8

C: 79 वर्ण

main(i,a)char**a;{i=i<<8|strtol(a[1],a+1,0);*a[1]++?main(i,a):printf("%u",i);}

संपादित करें: C ++ को हटा दिया गया, हेडर के बिना संकलित नहीं किया जाएगा; जीसीसी के साथ, printfऔर strtolफ़ंक्शन कॉल अंतर्निहित कार्यों को ट्रिगर करता है, इसलिए हेडर को छोड़ दिया जा सकता है। टिप्स के लिए Thx को @ugoren करें। यह अतिरिक्त विकल्पों के बिना के रूप में संकलित करेगा gcc।

EDIT2: returnवास्तव में बेमानी है :)

— निम
स्रोत

मुख्य का बहुत चालाक उपयोग () :) .. मेरा संस्करण 116bytes था।

— अकीरा

मुझे एक विभाजन दोष मिलता है।

— नाथन उस्मान

@ जॉर्ज, आपका इनपुट क्या है और आप इसे कैसे चला रहे हैं?

— निम

मैं इसे codepad.org के

— नाथन उस्मान

यह C ++ में काम नहीं करेगा, आप मुख्य पुनरावर्ती कॉल नहीं कर सकते।

— स्कॉट लोगन

7

गोल्फस्क्रिप्ट - 16 वर्ण

{[~]2%256base}:f

एक स्टैंडअलोन कार्यक्रम के रूप में, यह 11 साल की उम्र में भी छोटा है।

~]2%256base

बेहद सीधा। इनपुट स्ट्रिंग ( ~) का मूल्यांकन करता है और इसे एक सरणी में रखता है []। चूंकि .स्ट्रिंग में s स्टैक के शीर्ष को डुप्लिकेट करता है, हम केवल सरणी में हर दूसरे शब्द को लेते हैं ( 2%)। अब हमारे पास एक सरणी है जो मूल रूप से एक आधार संख्या 256 का प्रतिनिधित्व करता है, इसलिए हम रूपांतरण करने के लिए एक अंतर्निहित फ़ंक्शन का उपयोग करते हैं। ( 256base)।

— Nabb
स्रोत

बहुत चालाक। मुझे लगता है कि बेस 10 को आधार 10 या बेस 16 कहने के लिए अलग तरह से व्यवहार किया जाता है फिर कहां 48 => 0?

— जिब्बलर

@gnibbler: मुझे यकीन नहीं है कि आप क्या सुझाव दे रहे हैं - आधार फ़ंक्शन सभी आधारों को उसी तरह से संभालता है, जैसे {:B;{\B*+}*}:base(हालांकि वास्तविक फ़ंक्शन दूसरे तरीके से रूपांतरण के लिए अतिभारित है)। यह ध्यान रखना दिलचस्प है कि स्ट्रिंग्स के लिए बेस रूपांतरण सरणियों के समान होता है (जैसे स्ट्रिंग्स केवल नेस्टिंग के बिना एरे होते हैं, लेकिन एक अलग आउटपुट प्रारूप के साथ)।

— नबंवर

हाँ, मैं तार के आधार रूपांतरणों के बारे में सोच रहा था, इसलिए मैं baseअपने उत्तर के लिए पर्याप्त रूप से पर्याप्त नहीं दिख रहा था

— gnibbler

बहुत चालाक। अब IPv6 एड्रेस के लिए ऐसा करें। :)

— इल्मरी करोनें

6

Befunge - 2x11 = 22 वर्ण

इतने करीब, एक दिन Befunge जीत जाएगा।

>&+~1+#v_.@
^*4*8*8<

व्याख्या

Befunge की सबसे बड़ी विशिष्ट विशेषता यह है कि इसके बजाय अधिकांश भाषाओं की तरह निर्देशों का एक रैखिक सेट है; यह एकल चरित्र निर्देशों का 2 डी ग्रिड है, जहां नियंत्रण किसी भी दिशा में प्रवाहित हो सकता है।

>      v
^      <

ये पात्र हिट होने पर नियंत्रण की दिशा बदल देते हैं, इससे मुख्य लूप बन जाता है।

 &+~1+

यह एक संख्या को इनपुट करता है और इसे स्टैक पर धकेलता है ( &), स्टैक के शीर्ष दो मानों को पॉप करता है, उन्हें जोड़ता है और उन्हें स्टैक पर वापस धकेलता है ( +), एक एकल वर्ण को इनपुट करता है और स्टैक पर इसका एससीआई मान रखता है ()~ ), फिर स्टैक पर 1 धक्का देता है और उन्हें जोड़ता है ( 1+)।

दुभाषिया मैं इनपुट के अंत के लिए रिटर्न -1 का उपयोग कर रहा हूं, कुछ रिटर्न 0 के बजाय इसलिए कि 1+उनके लिए भाग हटाया जा सकता है।

      #v_.@

#अगले चरित्र को छोड़ देने का कारण बनता है, फिर _स्टैक से एक मूल्य पॉप करता है और यदि यह शून्य नियंत्रण दाएं भेजता है, अन्यथा इसे बाएं भेजता है। यदि मान शून्य था .तो स्टैक से एक मान उत्पन्न होता है और इसे पूर्णांक के रूप में आउटपुट करता है और @प्रोग्राम को रोकता है। अन्यथा vवापस लूप पर नियंत्रण भेजता है।

^*4*8*8<

यह केवल स्टैक के शीर्ष मूल्य को 256 से गुणा करता है और स्टार्ट पर नियंत्रण लौटाता है।

— Nemo157
स्रोत

मेरी अज्ञानता को क्षमा करें, लेकिन क्या यह 19 वर्ण होना चाहिए? मैं समझता हूं कि आप 2x11 क्यों कहते हैं, लेकिन यह उस तरह से काम क्यों करता है?

— काइल रोज़ेंडो

Befunge एक 2d भाषा है, अगर आप >v<^इस कार्यक्रम में वास्तव में मुख्य लूप की तलाश करते हैं। मुझे लगता है कि इस मामले में नियंत्रण वास्तव में नीचे के उन आखिरी 3 स्थानों से नहीं गुजरता है, लेकिन मुझे लगता है कि बेफ़ुंज कार्यक्रमों को सबसे छोटी बाउंडिंग आयत के रूप में गिनना आसान है; और यदि आप नियंत्रण के प्रवाह की कोशिश और गणना करने के लिए थे, तो आप स्व-संशोधित कार्यक्रमों के साथ परेशानी में पड़ जाते हैं।

— निमो 157

5

रूबी (40)

q=->x{x.gsub(/(\d+)\.?/){'%02x'%$1}.hex}

->

q["192.168.1.1"]
=> 3232235777

— jsvnm
स्रोत

Regexp का उपयोग करने का अच्छा विचार है।

— हौलेथ

बहुत चालाक! इसके अलावा, आप लिख सकते हैं to_i 16के रूप में hexकुछ अक्षर को बचाने के लिए।

— पॉल प्रेस्टिज

धन्यवाद @chron है कि दोनों इस और बना लिंक 4 अक्षर छोटे

— jsvnm

4

रूबी - 46 वर्ण

require"ipaddr"
def f s;IPAddr.new(s).to_i;end

— gnibbler
स्रोत

मुझे लगता है कि धोखा का गठन होता है। ;-)

— क्रिस जस्टर-यंग

3

गोल्फस्क्रिप्ट - 21 वर्ण

{'.'/{~}%{\256*+}*}:f

— gnibbler
स्रोत

+1 अच्छा ठोस समाधान। क्या आप नहीं चाहते कि गोल्फस्क्रिप्ट बिट-शिफ्टिंग ऑपरेटर प्रदान करे? ;-) (हालांकि, अगर मुझे पता है कि उन्हें कौन से प्रतीकों के लिए बाध्य होना चाहिए, तो हिम्मत हुई।)

— क्रिस जस्टर-यंग

3

पायथन 56 45

c=lambda x:eval('((('+x.replace('.','<<8)+'))

— एलेक्ज़ेंड्रु
स्रोत

3

सी ++ - बहुत सारे आकर्षण

#include <boost/algorithm/string.hpp>
#include <string>
#include <vector>
uint f(std::string p)
{
        std::vector<std::string> x;
        boost::split(x,p,boost::is_any_of("."));
        uint r=0;
        for (uint i = 0; i < x.size(); i++)
                r=r*256+atoi(x[i].c_str());
        return r;
}

— grokus
स्रोत

@ जॉर्ज एडिसन: बूस्ट का उपयोग करके वर्णों की संख्या के साथ नीचे आने में मदद मिलती है? :)

— अकीरा

3

पॉवरशेल 66 61

जॉय के जवाब पर विविधता:

filter I{([ipaddress](($_-split'\.')[3..0]-join'.')).address}

PS C:\> '192.168.1.1' | I
3232235777
PS C:\> '10.10.104.36' | I
168454180
PS C:\> '8.8.8.8' | I
134744072

— तिव आविल
स्रोत

अर्घ, मुझे लगता है कि याद करने के लिए बेवकूफ होना चाहिए ...

— जॉय

3

AWK ~ 47 वर्णों में

यहाँ पहले-टाइमर ... उम, यकीन नहीं है कि यह कैसे गिना जाए, लेकिन 'गूंज' के बिना यह AWK में 47 वर्ण है। (बिल्कुल बोगी गोल्फ नहीं है, लेकिन यह छेद में है।)

echo $addr | /bin/awk -F\. '{print $1*16777216+$2*65536+$3*256+$4}'

पूरा दिन जल्दी #tbt के लिए भी, तो मैं वास्तव में एक कार्यक्रम से मुलाकात की !!! * 8)

बैनर का दिन।

— ब्लेयर वमन
स्रोत

1

स्वागत हे! आप केवल उस बॉडी को गिनेंगे जिसे आप एक अचूक स्क्रिप्ट में डालेंगे। इस जवाब को देखें । आपके मामले में आप केवल गिनती करेंगे {print $1*16777216+$2*65536+$3*256+$4}। निश्चित रूप से आपको क्षेत्र विभाजक को एक ध्वज के रूप में निर्दिष्ट करने के बजाय कार्यक्रम में ले जाना होगा।

— जोनाह

3

बैश - 46

विषयसूची

आपको 4 अलग-अलग गोल्फ संस्करण मिलेंगे:

echo $[_=32,`printf "%d<<(_-=8)|" ${1//./ }`0]                        # 46chr
set -- ${1//./ };echo $[$1<<24|$2<<16|$3<<8|$4]                       # 47chr
v=('|%d<<'{24,16,8,0});printf -vv "${v[*]}" ${1//./ };echo $[0$v]     # 65chr
mapfile -td. i<<<$1;for((a=o=0;a<4;o+=i[a]<<(3-a++)*8)){ :;};echo $o  # 68chr

नया संस्करण! 2018-11-15 अधिक गोल्फ, 46 चार

echo $[_=32,`printf "%d<<(_-=8)|" ${1//./ }`0]

व्याख्या

मैं $_और अधिक गोल्फ के लिए इस्तेमाल किया ।
सिंटेक्स ${1//./ }हर डॉट्स .को रिक्त स्थान द्वारा स्थानापन्न करेगा ।
तो printfकुछ इस तरह प्रस्तुत करना होगा192<<(_-=8)|168<<(_-=8)|1<<(_-=8)|1<<(_-=8)|
फिर हम 0अंतिम OR के बाद जोड़ देंगे | और
32_ को पूर्व निर्धारित । बैश का निर्माण बाएं से दाएं पढ़ा जाएगा, इसलिए पहली पाली में , दूसरे पर, और इसी तरह से बनाएं ।$((_-=8))2416

कार्रवाई में:

set -- 192.168.1.1
echo $[_=32,`printf "%d<<(_-=8)|" ${1//./ }`0]
3232235777

मज़े के लिए: इसके $_बाद, सामग्री प्राप्त करने की कोशिश कर रहा है :

echo $_
3232235777
; बी
set -- 192.168.1.1
echo $_ $[_=32,`printf "%d<<(_-=8)|" ${1//./ }`0] $_
192.168.1.1 3232235777 0
ठीक है, यह सही है 32 - 4 x 8 = 0

एक समारोह में:

ip2int() {
    echo $[_=32,`printf "%d<<(_-=8)|" ${1//./ }`0]
}
ip2int 192.168.1.1
3232235777
ip2int 255.255.255.255
4294967295
ip2int 0.0.0.0
0

या लूप में: -> 60

ip2int() {
    for i;do
        echo $[_=32,`printf "%d<<(_-=8)|" ${i//./ }`0]
    done
}

ip2int 192.168.1.1 10.10.104.36 8.8.8.8 1.1.1.1 255.255.255.255 0.0.0.0
3232235777
168454180
134744072
16843009
4294967295
0

bash (v4.1 +): 47

पहिला पद

set -- ${1//./ };echo $[$1<<24|$2<<16|$3<<8|$4]

स्पष्टीकरण:

सिंटेक्स ${1//./ }हर डॉट्स .को रिक्त स्थान द्वारा स्थानापन्न करेगा ।
set --स्थितीय मानदंड निर्धारित करें ($@=($1 $2 $3...) )
तो set -- ${1//./ }बंट जाएगा $1डॉट्स और सेट के द्वारा $1, $2, $3और $4यदि स्ट्रिंग containg 3डॉट्स (और कोई रिक्ति नहीं)।

कार्रवाई में:

set -- 192.168.1.1
set -- ${1//./ };echo $[$1<<24|$2<<16|$3<<8|$4]
3232235777

या एक समारोह में:

ip2int() {
    set -- ${1//./ }
    echo $[$1<<24|$2<<16|$3<<8|$4]
}
ip2int 192.168.1.1
3232235777
ip2int 0.0.0.0
0

या लूप में: -> 61

for i;do set -- ${i//./ };echo $[$1<<24|$2<<16|$3<<8|$4];done

कार्रवाई में:

ip2int() {
    for i;do
        set -- ${i//./ }
        echo $[$1<<24|$2<<16|$3<<8|$4]
    done
}

ip2int 192.168.1.1 10.10.104.36 8.8.8.8 1.1.1.1 0.0.0.0
3232235777
168454180
134744072
16843009
0

एक और संस्करण अलग गोल्फ: 65

v=('|%d<<'{24,16,8,0});printf -vv "${v[*]}" ${1//./ };echo $[0$v]

नमूना:

ip2int() {
    v=('|%d<<'{24,16,8,0});printf -vv "${v[*]}" ${1//./ };echo $[0$v]
}

ip2int 255.255.255.255
4294967295
ip2int 10.10.104.36
168454180

एक लूप में (+14): 82

ip2int() {
    for i;do
        v=('|%d<<'{24,16,8,0})
        printf -vv "${v[*]}" ${1//./ }
        echo $[0$v]
    done
}

* या थोड़ा अधिक बदसूरत: 70 *

v=('|%d<<'{24,16,8});printf -vv "${v[*]}" ${1//./ };echo $[0${v%<<2*}]

जहां हम printfकुछ तार दे जैसे |192<<24 |168<<16 |1<<8|1<<24 |0<<16 |0<<8हम अंत में कटौती करने के लिए है<<2... ।

साथ गोल्फ `mapfile`, अब: 68

ip2int() {
    mapfile -td. i<<<$1;for((a=o=0;a<4;o+=i[a]<<(3-a++)*8)){ :;};echo $o
}

या लूप के साथ: 82

ip2int() {
    for a;do
      mapfile -td. i<<<$a;for((a=o=0;a<4;o+=i[a]<<(3-a++)*8)){ :;};echo $o
    done
}

— एफ। होरी
स्रोत

क्या आप एक संक्षिप्त विवरण जोड़ सकते हैं? मैं बैश गोल्फ में जाने की कोशिश कर रहा हूँ और मैं इस set --भाग के साथ क्या हो रहा है का पालन नहीं करते । धन्यवाद।

— योना

@Jonah: set -- foo barसे स्थापित हो जाएगा $@के साथ foo के रूप में $1और बार के रूप में $2।

— एफ। हौरी

@ जोना ने नया संस्करण जोड़ा

— F. Hauri

स्पष्टीकरण के लिए धन्यवाद।

— योना

नया संस्करण! अधिक गोल्फ, -1 चार !!

— एफ। हौरी

2

विंडोज पॉवरशेल, 70

कोई दृष्टिकोण नहीं:

filter I{[int[]]$x=$_-split'\.'
$x[0]*16MB+$x[1]*64KB+$x[2]*256+$x[3]}

System.Net.IPAddress का उपयोग करने के साथ: 76

filter I{([ipaddress]($_-replace('(.+)\.'*3+'(.+)'),'$4.$3.$2.$1')).address}

परीक्षा:

> '192.168.1.1'|I
3232235777

— एक छोटा सा सिक्का
स्रोत

2

बेफुंज -93 - 36 अक्षर

&"~"2+::8****&884**:**&884***&++++.@

— MiffTheFox
स्रोत

2

पर्ल: DIY (oneliners के लिए।) (40)

$j=3;$i+=($_<<($j--*8))for split/\./,$x;

# $ I में मूल्य का उपयोग करें

DIY फ़ंक्शन (65):

sub atoi{my($i,$j)=(0,3);$i+=($_<<($j--*8))for split'.',shift;$i}

— केंट फ्रेड्रिक
स्रोत

तुम्हें पता है, एक स्ट्रिंग द्वारा विभाजित कर सकते हैं तो आप का उपयोग करके एक चरित्र को बचाने split'.'के बजायsplit/\./

— अनाम कायर

फ़ंक्शन संस्करण के साथ, हां, लेकिन इनलाइन संस्करण नहीं, क्योंकि आपको split q{.}शेल उद्धरण से बचने की आवश्यकता के आसपास प्राप्त करने की आवश्यकता होगी: /

— केंट फ्रेड्रिक

2

हास्केल - 14 वर्ण

(.) a=(256*a+)

GHCi में उपयोग:

Prelude> let (.) a=(256*a+)
Prelude> 192. 168. 0. 1
3232235521

एकमात्र समस्या यह है कि आपको डॉट के बाएं या दाएं रिक्त स्थान डालना होगा, अन्यथा संख्याओं को फ्लोटिंग पॉइंट के रूप में व्याख्या की जाएगी।

— Quasimodo
स्रोत

एक संक्षिप्त विवरण जोड़ने का मन?

— योना

डॉट इन्फिक्स ऑपरेटर को कम्प्यूटेशन करने के लिए पुनर्परिभाषित किया जाता है, वास्तव में बहुत स्मार्ट!

— मेमो

यह बहुत चालाक है, लेकिन यह सही इनपुट प्रारूप (रिक्त स्थान के कारण) का उपयोग नहीं करता है

— 12M2121

2

सी # - 77 चार्ट

Func<string,uint>F=s=>s.Split('.').Aggregate(0u,(c,b)=>(c<<8)+uint.Parse(b));

— Mormegil
स्रोत

2

जावास्क्रिप्ट (45 अक्षर)

.reduce()ES5 और एरो फ़ंक्शंस में शुरू की गई एरे विधि के लिए समर्थन की आवश्यकता है ।

f=(x)=>x.split('.').reduce((p,c)=>p<<8|c)>>>0

— कृपया उठो
स्रोत

हुह ... मुझे नहीं पता था >>> उस तरह से काम किया (32 बिट पूर्णांक में बदलने के लिए)

— 12M2121

2

Powershell, 47 43 बाइट्स

$args-split'\.'|%{$r=([long]$r-shl8)+$_};$r

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

$f = {

$args-split'\.'|%{$r=([long]$r-shl8)+$_};$r

}

@(
    ,("192.168.1.1",3232235777)
    ,("10.10.104.36",168454180)
    ,("8.8.8.8",134744072)
) | % {
    $s,$expected = $_
    $result = &$f $s
    "$($result-eq$expected): $result"
}

आउटपुट:

True: 3232235777
True: 168454180
True: 134744072

— Mazzy
स्रोत

2

05AB1E , 5 बाइट्स

'.¡₁β

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

— hakr14
स्रोत

1

C # - 120 वर्ण

float s(string i){var o=i.Split('.').Select(n=>float.Parse(n)).ToList();return 16777216*o[0]+65536*o[1]+256*o[2]+o[3];}

मेरा पहला कोड गोल्फ - कोमल होना;)

— काइल रोजेंडो
स्रोत

आप अपने पहले '=' के आसपास रिक्त स्थान को हटा सकते हैं। हालाँकि, आपकी मुख्य समस्या int overflow;) है। याद रखें, एक IP पता 4 पूर्ण बाइट लेता है।

— नेलियस

@ नेलियस - काफी सही। मैंने यह जाँचने के बारे में भी नहीं सोचा कि मूल रूप से संकलन पर जाँच की गई थी। धन्यवाद, अब ठीक कर देंगे।

— काइल रोज़ेंडो

1

D: 84 वर्ण

uint f(S)(S s)
{
    uint n;
    int i = 4;

    foreach(o; s.split("."))
        n += to!uint(o) << 8 * --i;

    return n;
}

— जोनाथन एम डेविस
स्रोत

मुझे नहीं पता डी मुझे माफ कर दो अगर यह व्हॉट्सएप संवेदनशील है जैसे अजगर, लेकिन यह गोल्फ नहीं दिखता है। क्या आप डबल-लाइन विराम को हटा सकते हैं या अर्ध-उपनिवेशित कथनों के बीच की रेखा टूट सकती है?

— जोनाह

1

पायथन 3.2 (69)

sum((int(j)*4**(4*i)) for i,j in enumerate(input().split('.')[::-1]))

— l0nwlf
स्रोत

1

PHP (कोई बिलियन / इवेल नहीं) - 54

<foreach(explode(".",$argv[1])as$b)$a=@$a<<8|$b;echo$a;

— अरनौद ले ब्लांक
स्रोत

के साथ इस खुले नहीं करना चाहिए <?php, न कि केवल <?

— TRIG

@TRiG, मेरा मानना है कि आप config फाइल में पीएचपी ओपनिंग सीमांकक को बदल सकते हैं। इस मामले में उपयोगी।

— Xeoncross सेप

@Xeoncross। आह। साफ। मैं कोशिश कर सकता हूं कि एक दिन, सिर्फ अपने कामगारों के सिर के साथ गड़बड़ करने के लिए।

— टीआरजी

1

पर्ल, 14 वर्ण:

sub _{unpack'L>',pop}

# Example usage
print _(10.10.104.36) # prints 168454180

— ग्रिमी
स्रोत

5

आप उस 14 पात्रों को कैसे बनाते हैं? मेरी गिनती 21 है।

— पीटर टेलर

1

स्टैक्स , 9 बाइट्स

üL▼ü╛tΓi╨

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

— पुनरावर्ती
स्रोत

1

पर्ल 6 , 16 बाइट्स

{:256[m:g/\d+/]}

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

— nwellnhof
स्रोत

1

C (gcc) `-m32` / POSIX, 33 बाइट्स

f(a){inet_aton(a,&a);a=ntohl(a);}

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

एक बड़े endian मंच पर, आप बस के साथ मैक्रो निर्धारित कर सकता है -Df=inet_atonके लिए 13 बाइट्स ।

— nwellnhof
स्रोत

IPv4 पूर्णांक रूपांतरण समारोह

PHP - 21 वर्ण

MySQL - 20 वर्ण

रूबी (कोई निर्माण / निकासी नहीं) - 47

गोल्फस्क्रिप्ट - 16 वर्ण

Befunge - 2x11 = 22 वर्ण

व्याख्या

रूबी (40)

रूबी - 46 वर्ण

गोल्फस्क्रिप्ट - 21 वर्ण

पायथन 56 45

सी ++ - बहुत सारे आकर्षण

पॉवरशेल 66 61

AWK ~ 47 वर्णों में

बैश - 46

विषयसूची

नया संस्करण! 2018-11-15 अधिक गोल्फ, 46 चार

व्याख्या

या लूप में: -> 60

bash (v4.1 +): 47

या लूप में: -> 61

एक और संस्करण अलग गोल्फ: 65

साथ गोल्फ mapfile, अब: 68

विंडोज पॉवरशेल, 70

बेफुंज -93 - 36 अक्षर

पर्ल: DIY (oneliners के लिए।) (40)

DIY फ़ंक्शन (65):

हास्केल - 14 वर्ण

सी # - 77 चार्ट

जावास्क्रिप्ट (45 अक्षर)

Powershell, 47 43 बाइट्स

05AB1E , 5 बाइट्स

D: 84 वर्ण

पायथन 3.2 (69)

PHP (कोई बिलियन / इवेल नहीं) - 54

पर्ल, 14 वर्ण:

स्टैक्स , 9 बाइट्स

पर्ल 6 , 16 बाइट्स

C (gcc) -m32 / POSIX, 33 बाइट्स

साथ गोल्फ `mapfile`, अब: 68

C (gcc) `-m32` / POSIX, 33 बाइट्स