बड़ा या छोटा एंडियन

57

एक प्रोग्राम या फ़ंक्शन लिखें, जो Lथोड़ा एंडियन आर्किटेक्चर Bपर रन करने या बड़े एंडियन आर्किटेक्चर पर रन करने पर आउटपुट देता है । लोअर केस आउटपुट lया bस्वीकार्य भी है।

कोई इनपुट नहीं है।

स्कोरिंग कोड गोल्फ है, इसलिए सबसे कम बाइट्स वाला कोड जीत जाता है।

संपादित करें: नीचे दी गई टिप्पणियों के अनुसार, मैं स्पष्ट कर रहा हूं कि प्रविष्टि को आर्किटेक्चर पर चलने में सक्षम होना चाहिए।

मेरा मानना ​​है कि केवल एक ही उत्तर है जो इसे प्रभावित करता है, और उस उत्तर ने स्पष्ट रूप से संकेत दिया है कि यह मामला है।

code-golf 
— लियाम
स्रोत
1
बॉक्स की मेमोरी। मुझे यकीन नहीं है कि आपका क्या मतलब है
— Liam
7
मुझे लगता है कि यह एक दिलचस्प चुनौती है (और यह आदर्श से बाहर है) लेकिन इसका परीक्षण करना बेहद कठिन है। खासकर जब से अधिकांश कोड अत्यंत विशिष्ट मंच होंगे।
— DJMcMayhem
7
हाँ, मुझे लगता है कि यह दिलचस्प होगा क्योंकि उम्मीद है कि यह कुछ ऐसा है जो एसोलैंग्स और गोल्फ भाषाओं में 'सामान्य' भाषाओं की तुलना में कठिन समय है। मुझे लगता है कि वे यह सत्यापित करना मुश्किल नहीं होगा। सबसे खराब स्थिति में उन्हें हाथ से सत्यापित किया जाना चाहिए
— लियाम
2
मुझे लगता है कि एक विशिष्ट मशीन कोड पर आधारित एक उत्तर की मनाही है? अन्यथा B0 4C C3, जो है mov al, 'L' / retया unsigned char f(){ return 'L'; }, एक मान्य x86 उत्तर होगा।
— मार्गरेट ब्लूम
5
वाहवाही! एक कोड गोल्फ चुनौती के लिए जिसमें सामान्य-प्रयोजन प्रोग्रामिंग भाषाएं प्रतिस्पर्धी हो सकती हैं।
— 21 मई को PellMell

जवाबों:

42

पायथन, 33 बाइट्स

import sys
exit(sys.byteorder[0])

sys.byteorder'little'या तो या 'big'(और उन में से जो कोड को देखे बिना इस वाक्य को पढ़ेंगे, का [0]अर्थ है पहले वर्ण को लें)।

— एंडर्स कसीर्ग
स्रोत
चुनौती कहती है कि आउटपुट होना चाहिए Lऔर B(या लोअरकेस वेरिएंट), पूरे शब्द नहीं।
— user2428118
43
इसलिए यह कहते हैं sys.byteorder[0], अर्थात् की पहली चार byteorder।
— s3lph 12
36

सी, 26 बाइट्स

a=66<<24|76;f(){puts(&a);}

32-बिट intऔर ASCII वर्णों को मानता है । Amd64 (छोटे-एंडियन) और मिप्स (बड़े-एंडियन) पर परीक्षण किया गया।

जीसीसी, 23 बाइट्स

00000000: 613d 2742 0000 4c27 3b66 2829 7b70 7574  a='B..L';f(){put
00000010: 7328 2661 293b 7d                        s(&a);}

Feersum द्वारा सुझाया गया। बहु-चरित्र स्थिरांक का मूल्य कार्यान्वयन-निर्भर है, लेकिन यह जीसीसी में काम करता है। उसी आर्किटेक्चर पर परीक्षण किया गया।

— एंडर्स कसीर्ग
स्रोत
7
कम है रों अशक्त बाइट्स के साथ बदला जा सकता है। a='B\0\0L';\0
— feersum
1
@ फ़ेर्सम बहु-चरित्र स्थिरांक की समाप्ति कार्यान्वयन निर्भरता प्रतीत होती है। मैं आमतौर पर कोड गोल्फ में इस बारे में चिंता नहीं करता, लेकिन यह चुनौती सभी कार्यान्वयन के बीच अंतर करने के बारे में है।
— एंडर्स केसरग
क्या यह कोड वर्तमान में GCC के अलावा किसी और चीज़ में काम करता है?
— feersum
1
@ Faersum C89 दोनों की अनुमति देता है।
— एंडर्स केसरग
1
X6c (विजुअलएज C ++ प्रोफेशनल / सी के लिए AIX कंपाइलर, वर्जन 6) का उपयोग करके RS6000 पर AIX 5.2 पर 26 बाइट प्रोग्राम को सफलतापूर्वक "B" प्रिंट करता है
— जैरी यिर्मयाह
24

MATLAB / ऑक्टेव, 24 बाइट्स

[~,~,e]=computer;disp(e)

computerसमारोह के बारे में, ठीक है, कंप्यूटर उस पर चल रहा है जानकारी देता है। तीसरा आउटपुट एंडियननेस है: Lया Bक्रमशः छोटे या बड़े-एंडियन के लिए।

Ideone पर यह प्रयास करें ।

— लुइस मेंडो
स्रोत
1
क्या। इस stackoverflow के लिए somethign है, मुझे यह पता नहीं था!
— ब्रेन गाइडर
20

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

_=>"BL"[new Int8Array(Int16Array.of(1).buffer)[0]]

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

— एंडर्स कसीर्ग
स्रोत
5
वेबजीएल लोगों ने सोचा कि यह एक अच्छा विचार है, जीपीयू से गुजरने के दौरान धीरज को बदलने से बचने के लिए। बहुत ज्यादा बाकी सभी ने इसे बेवकूफी समझा ... :(
— gsnedders
11

सी, 36 35 बाइट्स

1 बाइट थैंक्स टू @algmyr और @owacoder।

main(a){printf(*(char*)&a?"L":"B");}
main(a){putchar(66+10**(char*)&a);}
main(a){putchar("BL"[*(char*)&a]);}

यहाँ क्रेडिट ।

जब से मेरे पास एक बड़ी-एंडियन मशीन नहीं है, तब तक अप्रयुक्त।

— लीक नन
स्रोत
2
क्या सी कल्पना एक-तर्क mainफ़ंक्शन की अनुमति देता है ?
— कोडइंचौस
@codesinchaos हाँ यह करता है। यह दिए गए कमांड लाइन तर्कों की संख्या होगी। आमतौर पर यहां इसका उपयोग एक चर के लिए किया जाता है 1क्योंकि कोई इनपुट नहीं दिया जाता है (और प्रोग्राम का नाम हमेशा पहले तर्क के रूप में गिना जाता है)
— लियाम
2
@ लियम: यदि 0 या 2 के अलावा किसी अन्य चीज़ की अनुमति है तो C11 में परिभाषित है।
1
या main(a){putchar("BL"[*(char*)&a]);}।
— उल्लू के जूल
2
यदि आप कॉल कन्वेंशन के साथ गड़बड़ करते हैं तो यह 31 हो जाता है main(char a){putchar("BL"[a]);}:।
— एंड्रिया बियोन्डो
8

गणितज्ञ, २२

{B,L}[[$ByteOrdering]]

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

— Mr.Wizard
स्रोत
1
बिल्ट-इन ठीक हैं (अधिकांश उत्तर भी उनका उपयोग कर रहे हैं)
— लियाम
2
और एक बार फिर, गणितज्ञ के पास एक अंतर्निहित है!
— 12 अक्टूबर को gcampbell
3
मुझे लगता है कि यह एक स्निपेट है, न कि एक कार्यक्रम या फ़ंक्शन, और आपको &इसे एक फ़ंक्शन बनाने के लिए जोड़ना चाहिए । (लेकिन एक "कार्यक्रम" का गठन करने पर असहमति हो सकती है।)
— एंडर्स कासोर्ग
1
@Anders मैं पीसीजी के लिए मौजूदा मानकों (अगर मैं कभी था) लेकिन IMHO एक व्याख्या की भाषा में से एक लाभ यह है कि एक टुकड़ा है के साथ वास्तव में परिचित नहीं हूँ है एक कार्यक्रम। यह स्टैंड-अलोन तरीके से चलाया जा सकता है जितना कि मैथेमेटिका के किसी अन्य कार्यक्रम में ।
— श्री। छिपकली
1
@ Mr.Wizard ध्यान दें कि मैथेमेटिका में एक "प्रोग्राम" एक स्टैंडअलोन स्क्रिप्ट (जिसे स्पष्ट मुद्रण की आवश्यकता होती है) को संदर्भित करता है, जबकि यह उत्तर REPL का उपयोग करता है।
— लीजनमोनमाल 978 22:30
8

सी, 27

एक बाइट लंबे समय तक, लेकिन यहाँ वैसे भी है:

f(){putchar(htons(19522));}
— डिजिटल आघात
स्रोत
यह ठीक काम किया, क्या आप मुझे यह समझा सकते हैं।
— एबीसीडैक्टर जूल
3
@ABcDexter 19522 का बाइनरी विस्तार 1001100 01000010(अलग बाइट्स के लिए स्थान) है। अब यदि आप प्रत्येक बाइट लेते हैं, तो वापस बेस 10 में कनवर्ट करें और ASCII तालिका जांचें, आप देखेंगे कि यह बाइट अनुक्रम के बराबर है LB। htonsहोगा अपने काम करते हैं , और putcharकेवल प्रिंट होगा LSB। बड़े-एंडियन सिस्टम में, जो कि Bछोटे-एंडियन में htonsहोगा, बाइट्स में फ़्लिप होगा, इसलिए एलएसबी है L।
— क्राल्टन
संकलक चेतावनी और -1 बाइट के 19522साथ बदलें 'LB'।
— स्टेन स्ट्रम
8

पावरपीसी मशीन कोड - 20 बाइट्स

PowerPC द्वि-एंडियन है (स्टार्टअप पर एंडियननेस स्थापित किया जा सकता है), इसलिए इस कोड को BE और LE मशीनों पर चलाने में सक्षम होने के चुनौती अनुरोध के अनुरूप होना चाहिए। यह एक ऐसा फंक्शन है जो वर्तमान में सेट किए गए 1 या वापसी पर निर्भर करता है। 'L''B'

एक समारोह के रूप में, AFAICT यह SVR4 PowerPC ABI (ppc32 पर लिनक्स द्वारा प्रयुक्त), पॉवरऑप ABI (AIX द्वारा प्रयुक्त जैसे) और OS X ABI के अनुरूप है। विशेष रूप से, यह सिर्फ इस तथ्य पर निर्भर करता है कि जीपीआर 0 एक अस्थिर खरोंच रजिस्टर है, और जीपीआर 3 का उपयोग "छोटे" मूल्यों को वापस करने के लिए किया जाता है।

00000000 <get_endian>:
   0:   7c 00 00 a6     mfmsr   r0
   4:   54 03 0f fe     rlwinm  r3,r0,1,31,31
   8:   1c 63 00 0a     mulli   r3,r3,10
   c:   38 63 00 42     addi    r3,r3,66
  10:   4e 80 00 20     blr

अब, यह इस प्रकार है:

  • MSR जीपी रजिस्टर 0 में पढ़ा जाता है; MSR में बिट 31 में एंडियनस सेटिंग्स होती हैं (0 = बड़ा एंडियन; 1 = थोड़ा एंडियन);
  • rlwinmकेवल उस बिट को अर्क करता है: यह जीपीआर 0 में मूल्य लेता है, आर ओटेस एल ईफ्ट 1 स्थान पर (ताकि अब स्थिति 0 में हो) और एम इसे 1 के साथ पूछता है (उन 31,31 2 द्वारा उत्पन्न मुखौटा ); परिणाम जीपी रजिस्टर 3 में डाल दिया गया है;
  • परिणाम को 10 और योग 66 से गुणा करें ( 'B') (10 के बीच अंतर है 'L'और 'B')
  • अंत में, कॉलर पर वापस लौटें

टिप्पणियाँ

  1. हां, सवाल प्रिंट करने के लिए कहता है , लेकिन यह स्पष्ट नहीं है कि मुझे विधानसभा में सामान कैसे प्रिंट करना चाहिए जो विभिन्न ऑपरेटिंग सिस्टमों पर अनमॉडिफाइड चलने की उम्मीद है। =)

  2. रुचि रखने वालों के लिए, rlwinm प्रलेखन देखें ; पावरपीसी के बारे में कुछ भी नहीं जानने के बाद, मुझे इस तरह के निर्देश बेहद दिलचस्प लगे।

    2018 अपडेट : रेमंड चेन पावरपीसी आर्किटेक्चर के बारे में एक श्रृंखला प्रकाशित कर रहा है, आप यहां अपने rlwinmदोस्तों और दोस्तों के बारे में शानदार पोस्ट पा सकते हैं ।

— माटेओ इटालिया
स्रोत
7

जावा 8, 96, 64 52 बाइट्स

()->(""+java.nio.ByteOrder.nativeOrder()).charAt(0);

इस एसओ जवाब पर आधारित एक गोल्फ । सारा श्रेय @LeakyNun और @AlanTuning को जाता है। जावा लूज़िंग स्ट्रीक रखता है।

96 बाइट्स:

 char e(){return java.nio.ByteOrder.nativeOrder().equals(java.nio.ByteOrder.BIG_ENDIAN)?'b':'l';}

64 बाइट्स:

char e(){return(""+java.nio.ByteOrder.nativeOrder()).charAt(0);}

बिना बी / सी के मेरे पास बड़े-एंडियन मशीन तक पहुंच नहीं है।

— नीला
स्रोत
1
char e(){return(""+java.nio.ByteOrder.nativeOrder()).charAt(0);}
— लीकी नून
char e(){return(""+java.nio.Bits.byteOrder()).charAt(0);}
— लीके नन
@LeakyNun मुझे जावा एपीआई में बिट्स नहीं दिख रहे हैं, और जब मैं इसे चलाता हूं तो यह मुझे "बिट्स इन जावा / एनआईओ में सार्वजनिक नहीं है"
— ब्लू
ओह, ठीक है।
— लीक नन
यदि आप एक लैम्ब्डा का उपयोग करते हैं तो 52 बाइट्स! ()->(""+java.nio.ByteOrder.nativeOrder()).charAt(0);
— शॉन वाइल्ड
6

पर्ल, 38 36 बाइट्स

say+(pack"L",1 eq pack"V",1)?"L":"B"

सिस्टम के डिफॉल्ट बाइट ऑर्डर में नंबर पैक करके और इसकी तुलना लिटिल-एंडियन बाइट ऑर्डर में पैक किए गए नंबर से करता है।

— एक स्पैगेटो
स्रोत
6

(छ) फोर्थ, २४ बाइट्स

here $4200004C , c@ emit

मान लेता है कि कोशिकाएँ 32 बिट्स हैं (और यह कि आपका फोर्थ दुभाषिया गॉर्थ के आधार उपसर्गों का समर्थन करता है )। यह बस 0x4200004C नंबर को मेमोरी में स्टोर करता है और फिर कम अंत में बाइट प्रदर्शित करता है।

— jwodder
स्रोत
5

सी, 34 बाइट्स

यह ASCII वर्ण एन्कोडिंग मानता है

main(a){putchar(66+10**(char*)a);}

बिना तर्क के बुलावे।

स्पष्टीकरण:

कॉल करने पर, a1. होगा *(char*)aपहला बाइट एक्सेस करता है a, जो कि छोटे-एंडियन प्लेटफॉर्म पर 1 होगा, बड़े-एंडियन प्लेटफॉर्म पर 0 होगा।

बड़े-एंडियन प्लेटफ़ॉर्म पर, यह कोड इसलिए 66 + 10 * 0 = 66 को पास करेगा putchar। 66 के लिए ASCII कोड है B। छोटे-एंडियन प्लेटफ़ॉर्म पर, यह 66 + 10 * 1 = 76 पास करेगा, जो कि ASCII कोड है L।

— celtschk
स्रोत
5

सी #, 60 52 बाइट्स

इस # में C # आश्चर्यजनक रूप से प्रतिस्पर्धी है।

char e=>System.BitConverter.IsLittleEndian?'L':'B';

C # 6 सिंटैक्स के लिए ग्रू को क्रेडिट।

60 बाइट्स:

char e(){return System.BitConverter.IsLittleEndian?'L':'B';}
— BgrWorker
स्रोत
C # 6 सिंटैक्स के साथ आप इसे थोड़ा छोटा कर सकते हैं: char e=>System.BitConverter.IsLittleEndian?'L':'B';बेशक, यह (साथ ही जावा उत्तर) वास्तव में मूल्य नहीं छापता है।
— ग्रू
प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! यह एक अच्छा पहला उत्तर है।
— एलेक्स ए।
5

जूलिया, 24 19 बाइट्स

()->ntoh(5)>>55+'B'

यह एक अनाम फ़ंक्शन है जो कोई इनपुट नहीं लेता है और वापस लौटता है Char। इसे कॉल करने के लिए, इसे किसी वैरिएबल पर असाइन करें। यह मानता है कि पूर्णांक 64-बिट हैं।

यह ntohफ़ंक्शन नेटवर्क बाइट ऑर्डर (बड़ा एंडियन) से होस्ट किए गए कंप्यूटर द्वारा उपयोग किए जाने वाले मूल्य की समाप्ति को परिवर्तित करता है। बड़े एंडियन मशीनों पर, ntohपहचान कार्य होता है क्योंकि कोई रूपांतरण नहीं किया जाना है। छोटी एंडियन मशीनों पर, बाइट्स को स्वैप किया जाता है, इसलिए ntoh(5) == 360287970189639680। जो कि, 0000010100000000000000000000000000000000000000000000000000000000बाइनरी में भी, संभवतः अधिक आसानी से, के बराबर है ।

यदि हम ntoh(5)55 के परिणाम से थोड़ा सा बदलाव करते हैं , तो हमें बड़ी एंडियन मशीनों पर 0 और छोटे एंडियन मशीनों पर 10 मिलेंगे। चरित्र को स्थिर करते हुए 'B', हम क्रमशः बड़े या छोटे एंडियन मशीनों के लिए 'B'या प्राप्त करेंगे 'L'।

FryAmTheEggman और डेनिस के लिए 5 बाइट्स धन्यवाद बचा लिया!

— एलेक्स ए।
स्रोत
32 बिट के लिए आपको 55 से 23 को बदलना होगा (16 बिट में 5 भी 7 होना चाहिए, मेरी गलती है)। मुझे लगता है कि डेनिस का मतलब कुछ ऐसा था ()->ntoh(5)>>55+'B':?
— FryAmTheEggman
1
f()='L'-ntoh(10)%16और f()='L'-ntoh(10)&10सभी प्लेटफार्मों पर काम करना चाहिए।
— डेनिस
5

आम लिस्प, 27 बाइट्स

SBCL और ECL पर परीक्षण किया गया। पोर्टेबल दृष्टिकोण के लिए, किसी को तुच्छ-सुविधाओं का उपयोग करना चाहिए ।

(lambda()'L #+big-endian'B)

#+अंकन एक है पढ़ने के समय हालत यह है कि पढ़ता अगले प्रपत्र केवल तभी सशर्त अभिव्यक्ति सही का आकलन। यहां स्थिति संपूर्ण #+big-endianपाठ है जिसका अर्थ है कि परीक्षण संतुष्ट है यदि :big-endianकीवर्ड *FEATURES*सूची से संबंधित है (एक सूची जिसमें अन्य चीजों के साथ प्लेटफॉर्म-विशिष्ट जानकारी शामिल है)। निम्नलिखित अभिव्यक्ति है 'B, जो परीक्षण के परिणाम के अनुसार या तो पढ़ी जाती है या छोड़ दी जाती है। यदि आपका प्लेटफ़ॉर्म बड़ा-एंडियन है और आप उपरोक्त फ़ॉर्म को REPL में लिखते हैं, तो यह बिल्कुल वैसा ही है जैसे आपने निम्नलिखित लिखा है:

CL-USER>(lambda()'L 'B)

(एनबी। CL-USER>प्रॉम्प्ट है)

एक फ़ंक्शन का शरीर एक निहित है PROGN, जिसका अर्थ है कि केवल अंतिम अभिव्यक्ति का मूल्यांकन वापस आ गया है। तो ऊपर वास्तव में प्रतीक देता है B। हालाँकि यदि रीड-टाइम स्थिति झूठी का मूल्यांकन करती है, तो फॉर्म इस तरह पढ़ता है जैसे आपने लिखा है:

CL-USER>(lambda()'L)

... जो केवल प्रतीक देता है L।

— कोर निपात
स्रोत
स्निपेट की अनुमति नहीं है; इसके बजाय पूर्ण कार्यक्रम या फ़ंक्शन लिखें।
— एर्ग आउटफोलर
@ EʀɪᴋᴛʜᴇGᴏʟғᴇʀ अपडेट किया गया है, धन्यवाद
— coredump
ध्यान दें: यदि केवल ओपी द्वारा स्पष्ट रूप से अनुमति दी जाती है, तो स्निपेट की अनुमति दी जाती है।
— एर्ग आउटफोलर
@ E @Gᴏʟғᴇʀ क्या आप इसके लिए कोई संदर्भ प्रदान कर सकते हैं? यहाँ और / या शेल स्निपेट पर अन्य REPL उत्तर हैं और यह मेटा पोस्ट सुझाव देगा कि REPL उत्तर डिफ़ॉल्ट रूप से ठीक हो सकते हैं। धन्यवाद।
— coredump
5

ARMv6 और बाद में: 20 बाइट्स मशीन कोड

0xE10F1000 : MRS   r0,CPSR        ; read current status register
0xE3110C02 : TST   r0,#1<<9       ; set Z flag if bit 9 set
0x03A0004C : MOVEQ r0,#'L'        ; return 'L' if Z clear
0x13A00042 : MOVNE r0,#'B'        ; return 'B' if Z set
0xEBxxxxxx : BL    putchar        ; print it (relative branch)

जब तक मेरे पास हाथ करने के लिए उपयुक्त मशीन नहीं है, तब तक अप्रयुक्त। CPSR का बिट 9 वर्तमान लोड / स्टोर एंडियननेस देता है।

— user1908704
स्रोत
आप फंक्शन से रिटर्न का उपयोग कर सकते हैं ( BX lr, यह है?) के बजाय putchar, क्योंकि r0लौटे परिणाम के लिए उचित रजिस्टर है।
— अनातोलीग जूल
वास्तव में, वह (वास्तव में MOV पीसी, lr) मेरे पिछले संपादन में से एक था। हालांकि यह पत्र को मुद्रित करने के लिए विनिर्देश को पूरा करता है, न कि केवल इसे वापस करना।
— user1908704
मैं संदर्भ को गलत पढ़ रहा हूं, लेकिन मुझे लगता है कि यह "अंगूठा 2" निर्देश एन्कोडिंग में किया जा सकता है। इसका मतलब यह होगा कि पहला निर्देश एआरएम वी 8 संदर्भ मैनुअल के पृष्ठ F7-2720 पर 32 बिट्स ("एन्कोडिंग टी 1" बना रहा, जो इसे 0xF3EF_8000 बना देगा); दूसरा भी 32 बिट्स है (ऑपरैंडिंग थोड़ा विचित्र है, लेकिन "i: Imm3" के साथ 0010 पर सेट किया जा सकता है और 00000010 तक "imm8", जो कि 0xF010_2F02 का समग्र निर्देश देता है। तीसरे निर्देश से पहले, हमें अगले दो MOV निर्देशों पर स्थितियों को नियंत्रित करने के लिए "ITE EQ" (0xBF0C) सम्मिलित करने की आवश्यकता है, जो 0x204C और ...
— Jules
... 0x2042 (कुल 2 बाइट्स की बचत)। फिर अंतिम बीएल निर्देश का प्रतिनिधित्व करना थोड़ा मुश्किल है क्योंकि पते के बिट्स जो हम नहीं जानते हैं कि हम जो निर्देश जानते हैं उसके बिट्स के बीच बिखरे हुए अंत नहीं हैं, लेकिन यह 32-बिट एन्कोडिंग भी है, इसलिए परिणाम 18 बाइट्स कुल हो (F3 EF 80 00 F0 10 2F 02 BF 0C 20 4C 20 42 F? ?? ?? ??)। मेरा मानना ​​है कि यह आर्किटेक्चर को ARMv8 और बाद में बदल देता है, हालांकि यह ARMv7 (?) में काम कर सकता है।
— जूल्स
4

पर्ल 5, 21 + 1 = 22 बाइट्स

के साथ भागो perl -E।

say ord pack(S,1)?L:B

Amd64 (छोटे-एंडियन) और मिप्स (बिग-एंडियन) पर परीक्षण किया गया।

— एंडर्स कसीर्ग
स्रोत
क्या -Eबाइट की गिनती में ध्वज वास्तव में आवश्यक है? आप बस कह सकते हैं कि आप पर्ल 5.10 का उपयोग करते हैं (क्योंकि sayकमांड इस संस्करण में उपलब्ध है)
— पॉल पिकार्ड
1
@PaPPicard लेकिन use 5.10.0;कई और बाइट्स है!
— एंडर्स कासोर्ग
1
@PaulPicard आपकी बात गलत है। पर्ल 5.10 के लिए -Eस्विच या useस्टेटमेंट की आवश्यकता होती है say।
— एंडर्स केसरग
3
-Eपीपीसीजी पर "मुक्त" है। कुछ जोड़ने की जरूरत नहीं।
— वेन
1
(हालाँकि -nऔर -pनहीं हैं)
— वेन
4

आर, 28 23 बाइट्स

substr(.Platform$endian,1,1)

.Platform$endianरिटर्न bigअगर बड़े एंडियन पर चलता है और littleअगर कम पर। इधर, का उपयोग कर substr, यह उत्पादन के पहले अक्षर को देता है, तो या तो bया l।

जैसा endianकि एकमात्र ऑब्जेक्ट eमें निहित वस्तु से शुरू होता है, .Platformहम इसे निम्न 23 बाइट्स कोड के लिए आंशिक मिलान के लिए धन्यवाद कम कर सकते हैं:

substr(.Platform$e,1,1)
— plannapus
स्रोत
3

क्लोजर, 46 44 बाइट्स

#(nth(str(java.nio.ByteOrder/nativeOrder))0)

यह एक फ़ंक्शन है जो मशीन के एंडियननेस को प्राप्त करने के लिए जावा बिलिन का उपयोग करता है। फिर इसका स्ट्रिंग प्रतिनिधित्व प्राप्त करें जो "LITTLE_ENDIAN"या तो होगा या "BIG_ENDIAN"जो भी स्ट्रिंग का पहला चरित्र चुनेगा और उसे वापस करेगा।

सहेजे गए 2 बाइट्स @ cliffroot का धन्यवाद ।

— मील की दूरी पर
स्रोत
वास्तव में क्लोजर क्या है, क्या यह लिस्प या जावा है?
— लीके नन
@LeakyNun शायद एक व्यावहारिक LISP है जो जावा के साथ काम करता है? य़ह कहना कठिन है।
— मील
#(nth(str(java.nio.ByteOrder/nativeOrder))0)2 बाइट्स छोटा है
— क्लिफरोट
3

माणिक, 3130 चरस।

puts [1].pack("s")>"\01"??L:?B

हम्म, एक बेहतर तरीका होना चाहिए। 5 वर्णों की गणना कम करें यदि चार को आउटपुट की आवश्यकता नहीं है क्योंकि मुझे लगता है कि अन्य समाधान मुद्रण को छोड़ देते हैं। यदि आप कुछ भी मुद्रित नहीं करना चाहते हैं तो "पुट" भाग को हटा दें।

— akostadinov
स्रोत
अगर मैं सही ढंग से याद, रूबी 1.9 के बाद, आप उपयोग कर सकते हैं ?Lऔर ?Bके स्थान पर puts :Lऔरputs "B"
— Sherlock9
मुझे लगता है कि puts [76,66].pack("s")[0]काम करेगा।
— वेन कॉनराड
@ शर्लक 9, धन्यवाद, एक चार कम। @WayneConrad, शायद अपना जवाब जोड़ें, मेरे पास परीक्षण करने के लिए हाथ में एक बड़ी एंडियन मशीन नहीं है, लेकिन बहुत कम एंडियन पर यह काम करता है। लेकिन इस तरह बदलने से काम नहीं होता puts [76,66].pack("s>")[0]:। इसका मतलब यह है कि बड़े एंडियन पर किसी कारण से काम नहीं करना संभव है जो मुझे अच्छी तरह से समझ में नहीं आता है। लेकिन यह काम करने लगता है (आपके समाधान से प्राप्त) puts [19522].pack("s>")[0]। WDYT? मुझे आश्चर्य है कि क्या मुझे बड़े एंडियन पर मूल्यांकन करने के लिए कुछ जगह मिल सकती है।
— अकोस्टैडिनोव
काश, मेरे पास परीक्षण करने के लिए एक बड़ी-एंडियन मशीन की भी कमी होती।
— वेन कॉनराड
3

बैश (और अन्य यूनिक्स गोले), 32 (33) बाइट्स

पहला और दूसरा प्रयास:

case `echo|od` in *5*)echo B;;*)echo L;;esac # portable
[[ `echo|od` =~ 5 ]]&&echo B||echo L         # non-portable

डेनिस के लिए धन्यवाद, छोटा संस्करण:

od<<<a|grep -q 5&&echo L||echo B  # non-portable
echo|od|grep -q 5&&echo B||echo L # portable

echoउपयोगिता हेक्स मान के साथ एक नई पंक्ति आउटपुट, 0Aहै, और कोई अन्य उत्पादन। इसके लिए <<<aहै 61 0A।

odउपयोगिता, डिफ़ॉल्ट रूप से, इनपुट दो-बाइट शब्दों के रूप में, की व्याख्या शून्य गद्देदार अगर बाइट की संख्या विषम है, और अष्टाधारी में धर्मान्तरित। इसका परिणाम गूंज के रूप 0A 00में होता है, जिसे 005000बड़े-एंडियन या 000012छोटे-एंडियन में परिवर्तित किया जाता है । छोटे-एंडियन और बड़े-एंडियन में 61 0Aहो जाता 005141है 060412। आयुध डिपो से भरा उत्पादन भी अर्थ हम उपयोग नहीं कर सकते पता और आकार डेटा शामिल हैं 0, 1या 2परीक्षण के लिए।

सिस्टम के एंडियननेस को उजागर करने के लिए कमांड को अच्छी तरह से परिभाषित किया गया है। से मानक :

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

संगतता नोट

मुझे यकीन नहीं है कि अगर echo|odउनके आसपास कोई दोहरा उद्धरण नहीं है, जिसके परिणामस्वरूप [तीन-शब्द तर्क में case] सभी प्रणालियों पर समर्थित है। मुझे यकीन नहीं है कि सभी सिस्टम शेल स्क्रिप्ट का समर्थन करते हैं, जिसमें कोई भी समाप्ति न्यूलाइन नहीं है। मैं ज्यादातर निश्चित हूं, लेकिन बड़े-एंडियन सिस्टम पर पैडिंग बाइट को जोड़ने के साथ ओड के व्यवहार का 100% नहीं। यदि आवश्यक हो, echo aतो पोर्टेबल संस्करणों के लिए उपयोग किया जा सकता है। सभी स्क्रिप्ट बश, ksh और zsh में काम करती हैं, और पोर्टेबल डैश में काम करती हैं।

— Random832
स्रोत
परिवर्तनों में से कोई भी आवश्यक नहीं है; बस एक शेल इसे भाषा के शीर्षक में काम करता है और आप सेट कर रहे हैं।
— डेनिस
1
@Dennis मैं विश्लेषण उस तरह करना पसंद ... हालांकि यह मजेदार है अगर मैं है लगता है कुछ अमानक कि बैश या दूसरों की तुलना में zsh में एक छोटा जवाब हो जाता है। शायद मैं वही दिखाई देगा जो साथ किया जा सकता[[
— Random832
1
विश्लेषण में कुछ भी गलत नहीं है। आखिरी पैराग्राफ सिर्फ आपको लगता है कि अगर कोई शेल-विशिष्ट उत्तर वैध है तो अनिश्चित थे ... od<<<a|grep -q 5&&echo L||echo Bबैश और अन्य में काम करना चाहिए।
— डेनिस
मैंने एक बड़े-एंडियन वीएम में इसका परीक्षण किया, और आपको उम्मीद के मुताबिक echo|odप्रिंट 0000000\n005000\n0000001करता है।
— डेनिस
@ user17752 क्योंकि एंडियनस के आउटपुट को प्रभावित नहीं करता है od -a।
— रैंडम 832
3

PHP, 16 बाइट्स

<?=pack(S,14)^B;

यह दो मौजूदा PHP उत्तरों में उपयोग नहीं किए गए दो ट्रिक का उपयोग करता है:

  1. पैक () या अनपैक () के लिए दिया गया मान कुछ भी हो सकता है, न कि केवल ० या १।
  2. बिटवाइज़ XOR ऑपरेटर ( ^) स्ट्रिंग्स पर काम करता है, और परिणाम केवल छोटे स्ट्रिंग के रूप में होता है, स्ट्रिंग इंडेक्सिंग या टर्नेरी ऑपरेटर की आवश्यकता से बचता है।
— कृपया उठो
स्रोत
2

नोड, 42 बाइट्स

n=>require('os').endianness()[0]

Pro: एक बिलिन है। Con: संपत्ति के नाम बहुत लंबे हैं

— Downgoat
स्रोत
2

पॉवरशेल, 44 बाइट्स

[char](66+10*[BitConverter]::IsLittleEndian)

अक्षर 66 है B, और 10 अक्षर बाद में 76 वें नंबर पर हैं L। एक 1संख्या के लिए डाले जाने पर "सच" का बूलियन मान बन जाता है । BitConverterएक मानक .NET क्लास है।

— बेन एन
स्रोत
1

रैकेट, 35 28 बाइट्स

(if(system-big-endian?)'B'L)

'Bया 'Lक्रमशः। मुझे बताएं कि क्या यह पर्याप्त विशिष्ट नहीं है :)

— winny
स्रोत
1

हास्केल (जीएचसी-केवल आकार-प्रतिबंधित संख्यात्मक प्रकार का उपयोग करके), 75 बाइट्स

import Unsafe.Coerce
import GHC.Int
f="BL"!!fromEnum(unsafeCoerce 1::Int8)

(एक बड़े-एंडियन वास्तुकला पर परीक्षण नहीं किया गया है, लेकिन ऐसा लगता है कि यह काम करना चाहिए !)

— जूल्स
स्रोत
1

के, 15 बाइट्स

    ("bl")@*6h$-8!`
    ,"l"

स्पष्टीकरण;

    From right to left;
    -8!`       /serialises the back tick and returns (0x010000000a000000f500)
    6h$-8!`    /This casts the result to `int which is type 6h(could have used `int$-8!`) - the result is (1 0 0 0 10 0 0 0 245 0i)
    *6h$-8!`   /* means first, we take the first item which is 1. Since it will be either 1 or 0, we can use it to index (@) into the two element list on the left i.e. ("bl")1 returns "l" and ("bl")0 returns b
— Chromozorz
स्रोत
1

बैश, 27 बाइट्स

iconv -tucs2<<<䉌|head -c1

䉌( U + 424C ) तीन UTF-8 बाइट के रूप में एन्कोड किया गया है: E4 89 8C।

यह माना जाता है कि iconvglibc से फ़ंक्शन का उपयोग करता है और UTF-8 लोकेल का उपयोग किया जाता है।

— कृपया उठो
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.