बिट्स और बाइट्स के साथ प्रोग्रामिंग

Question

इस चुनौती में आप एक साधारण भाषा के लिए दुभाषिया लिखने जा रहे हैं जिसे मैंने बनाया है। भाषा एक एकल संचायक ए पर आधारित है, जो लंबाई में बिल्कुल एक बाइट है। एक कार्यक्रम की शुरुआत में, ए = 0. ये भाषा निर्देश हैं:

!: उलटा

यह निर्देश बस संचायक के हर बिट को निष्क्रिय कर देता है। हर शून्य एक हो जाता है और हर एक शून्य हो जाता है। सरल!

>: शिफ्ट राइट

यह निर्देश A एक स्थान पर दाईं ओर प्रत्येक बिट को स्थानांतरित करता है। सबसे बाईं ओर एक शून्य बन जाता है और सबसे दाहिना बिट को छोड़ दिया जाता है।

<: शिफ्ट लेफ्ट

यह निर्देश हर एक बिट को बाईं ओर एक स्थान पर शिफ्ट करता है। सबसे दाहिना बिट शून्य हो जाता है और सबसे बाएं बिट को छोड़ दिया जाता है।

@: स्वप नबबल्स

यह निर्देश ए के शीर्ष चार बिट्स को नीचे चार बिट्स के साथ स्वैप करता है। उदाहरण के लिए, यदि A है 01101010और आप निष्पादित करते हैं @, तो A होगा 10100110:

 ____________________
 |                  |
0110 1010    1010 0110
      |_______|

यह सब निर्देश है! सरल, सही?

नियम

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

यहाँ कुछ छोटे प्रोग्राम हैं जो आपके सबमिशन का परीक्षण करते हैं। इससे पहले कि यह अपेक्षित परिणाम है तीर कोड है,:

• ! -> 255
• !>> -> 63
• !<@ -> 239
• !nop!&6*! -> 255

का आनंद लें!

Comments

मैं मान रहा हूँ ! -> 255कि हम यहाँ प्रति बाइट 8 बिट का उपयोग कर रहे हैं? प्रश्न स्पष्ट नहीं है।

— टोबी स्पाइट

@TobySpeight एक बाइट, परिभाषा के अनुसार, 8 बिट्स है।

— हाइपरन्यूट्रिनो

Answer 1

पायथ, 36 35 बाइट्स

u%@[t_G/G2yGi_jGJ16JG)x"!><@"H256z0

दोहन ​​परीक्षण

संचायक का आंतरिक प्रतिनिधित्व एक पूर्णांक है। यह पूर्णांक वांछित रूप में प्रत्येक पुनरावृत्ति पर 256 से मॉड-एड है। प्रदर्शन के संचालन कर रहे हैं -G-1, G/2, G*2और Gआधार 10, जहां के लिए आधार 16, उलट, और परिवर्तित वापस करने के लिए परिवर्तित Gसंचायक है।

मुझे हर चीज को नजरअंदाज करने के बारे में याद आती है। इसे हटा दिया गया है। धन्यवाद, @ डेनिस।

Comments

तो पायथ -G-1से छोटा है ~G? मुझे कुछ संदेह है।

— कैलक्यूलेटरफल

प्रश्न में कोड वास्तव में है t_G, जहां _नकारात्मकता है और tहै -1। पायथ में, का ~अर्थ है कुछ बिल्कुल अलग।

— इसहाक

मेरा मतलब था पायथन ~(बिटवाइज़ नॉट)

— कैलक्यूलेटरफ़्लीन

@CalculatorFeline मेरा कहना था कि पायथ में उस प्रभाव के साथ कोई 1-वर्ण फ़ंक्शन नहीं है, इसलिए उपरोक्त कोड (कम से कम उस ऑपरेशन के लिए) उतना ही अच्छा है जितना इसे प्राप्त करना है।

— इसहाक

Answer 2

सी, 96

ASCII (या संगत) इनपुट मानते हुए:

a;main(c){while(c=getchar()+1)a=(c^34?c^61?c^63?c^65?a:a*257/16:a/2:a*2:~a)&255;printf("%u",a);}

tidier:

a;
main(c){
  while(c=getchar()+1)
    a=(c^34?
      c^61?
        c^63?
          c^65?
            a
          :
            a*257/16
        :
          a/2
      :a*2:~a
    )&255;
  printf("%u",a);
}

मूल रूप से यह सिर्फ नेस्टेड टर्नरी एक्सप्रेशन का संग्रह है। मैं प्राप्त मूल्य में वृद्धि कर रहा हूं getchar()ताकि एक ईओएफ (-1) शून्य के मूल्य में परिणाम हो और कार्यक्रम बाहर निकल जाए।

(ideone लिंक)

Comments

मैंने स्वयं चुनौती का प्रयास किया और मैंने लगभग समान कोड लिखा। Btw। जब ऊपर की ओर शिफ्टिंग हो रही है तो आपका प्रोग्राम थोड़ा नहीं गिरा है (इनपुट: !<>परिणाम में होना चाहिए 127और नहीं 255)। सही प्रभाव प्राप्त करने के लिए या तो अपने aको परिभाषित करें char, या लाइन a&=255(और उपयोग करें %u) का उपयोग करें । इसके अलावा, आप अपनी उपेक्षा a^255को कम कर सकते हैं ~a। a>>4&15आपके से भी छोटा है (a&240)/16।

— मार्कडिफिएंट

आह, अच्छी बात है। पता चलता है कि प्रत्येक पुनरावृत्ति पर निचले 8 बिट्स को बाहर निकालना अधिक कुशल था।

— स्क्वीमिश ossifrage

इस स्थिति में आप प्रारूप स्ट्रिंग का उपयोग भी कर सकते %uहैं%hhu

— MarcDefiant

मैंने अभी इसे देखा है, लेकिन आप a/16|a*16इसके बजाय उपयोग कर सकते हैं a/16|(a&15)*16। शीर्ष पर कुछ बिट्स द्वारा हटा दिया जाता है &255।

— मार्कडेफिएंट

एक छोटा सुधार: a*257/16एक बाइट से छोटा है a/16|a*16।

— टोबी स्पाइट

Answer 3

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

पायथन में स्विच-केस सिंटैक्स की कमी के लिए एक शब्दकोश का उपयोग करता है। अधिक यहाँ देखें ।

a="0"*8
for i in input():a={"!":''.join(str(1-int(b))for b in a),"<":a[1:]+"0",">":"0"+a[:-1],"@":a[4:]+a[:4]}.get(i,a)
print(int(a,2))

संचायक एक स्ट्रिंग है जो अंत में आधार 10 नंबर में परिवर्तित हो जाती है।

उदाहरण I / O:

$ python3 bitsnbytes.py
!
255
$ python3 bitsnbytes.py
!>>
63
$ python3 bitsnbytes.py
!<@
239
$ python3 bitsnbytes.py
!nop!&6*!
255

Comments

यदि यह एक वास्तविक, इंटरैक्टिव दुभाषिया था, तो यह होगा for i in sys.stdin::)

— Zizouz212

@ Zizouz212 मेरा मानना ​​है कि अगर आप इंटरैक्टिव थे; यह मेरे लिए एक वास्तविक दुभाषिया जैसा दिखता है। ;)

— एलेक्स ए।

Answer 4

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

a=>[...a].reduce((p,c)=>c=='!'?p^255:c=='<'?p*2%256:c=='>'?p>>1:c=='@'?p/16|0+p%16*16:p,0)

बहुत कम के रूप में यह प्राप्त कर सकते हैं। एक अनाम फ़ंक्शन को परिभाषित करता है जो प्रोग्राम को इनपुट के रूप में लेता है।

• के लिए !, ले जाता है x XOR 255, के रूप में जे एस के ~विचार करेगा xएक 32-बिट संख्या।
• के लिए <, x2 से गुणा करता है और परिणाम मोड 256 लेता है।
• के लिए >, सही मायने में x1 बिट के बिट्स को दाईं ओर बदलता है ।
• के लिए @, फर्श x/16और यह करने के लिए कहते हैं x%16*16।

reduceएक बाइट को बचाने के उपयोग के सुझाव के लिए @vihan को धन्यवाद ।

Comments

आप <लगभग 4 बाइट बचाने के लिए उपयोग कर सकते हैं । कम करने के प्रयोग से कुछ बाइट्स भी बच सकती हैं

— डाउनगेट

@vihan क्या आप के <स्थान पर मतलब है ==? यदि ऐसा है, तो यह काम नहीं करेगा, क्योंकि नो-ऑप अक्षर गलत तरीके से एक ऑपरेशन करेंगे। मैंने अपने पिछले, 80-बाइट समाधान में इसका इस्तेमाल किया था।

— ETHproductions

PPCG पर ES6 वसा तीर मानक नहीं है कि आपको इसे परिभाषित करना है?

— मेयरमोनी

@SpeedyNinja मैं ऐसे किसी भी मानक के बारे में नहीं जानता, लेकिन अगर आप मुझे एक पोस्ट के बारे में बता सकते हैं, तो मैं अपना उत्तर संशोधित करूंगा।

— ETHproductions 3

Answer 5

सीजेएम, 37 बाइट्स

0q{"!><@"#"~ 2/ 2* GmdG*+ "S/=~255&}/

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

यह काम किस प्रकार करता है

0                   e# Push 0 (accumulator).
q                   e# Read from STDIN.
{                   e# For each character in the input:
  "!><@"#           e#   Find its index in "!><@" (-1 if not found).
  "~ 2/ 2* GmdG*+ " e#   Push that string.
  S/                e#   Split at spaces to push ["~" "2/" "2*" "GmdG*+" ""].
                    e#     "~"      : signed 64-bit bitwise NOT
                    e#     "2/"     : divide by 2
                    e#     "2*"     : multiply by 2
                    e#     "GmdG*+" : (x) -> (x/16) (x%16) -> (16(x%16) + (x/16))
                    e#     ""       : NOOP
  =~                e#  Select the corresponding string and evaluate it.
  255&              e#  Zero all but the 8 least significant bits.
}/                  e#

Answer 6

जावा (8), 514 483 411 366 359 239 224 229 198 194 187 186 184 182 181 180 177 वर्ण

वाह, यह बहुत नीचे चला गया है! मेरे सुझाव देने वाले सभी को धन्यवाद! मैं इसकी बहुत सराहना करता हूं!

interface T{static void main(String[]g)throws Exception{int i,a=0;while((i=System.in.read())!=10)a=(i==33?255-a:i==62?a/2:i==60?a*2:i==64?a>>4|a<<4:a)%256;System.out.print(a);}}

गोल्फिंग 31 (!) बाइटवाइज ऑपरेशन के साथ निबल स्वैप को अनुकूलित करके बाइट्स के रूप में लंबी Integer.???विधियों का विरोध किया ।

निबल्स को स्वैप करने के लिए बनाई गई अनावश्यक स्ट्रिंग को हटाकर गोल्फ 72 (!!!!) वर्ण। पहले से बहुत बेहतर !?

गोल्फ का उपयोग (!!) java.util.Scannerसे System.inसीधे और पढ़ने के उपयोग को हटाकर । ध्यान दें कि अब लैंबडा अभिव्यक्ति चला गया है, जावा 8 की अब आवश्यकता नहीं है! सिर्फ जावा 1 करना होगा!

क्लास को हटाकर 7 चार्ट बनाए गए (default)( publicकीवर्ड हटा दिया गया ), @bmarks के लिए धन्यवाद

गोल्फिंग 120 (!!!!!!!) उन सभी लम्बे Integerवर्ग के ऑपरेशनों को बिट फ्लिपिंग में बदल देता है 255 - a। अब यह बहुत कम है!

गोल्फ 15 (!) चर को गुणन और विभाजन में परिवर्तित करके, जबकि कथन से ब्रेसिज़ को हटाकर, और विधि के aभीतर स्थानीय बनाते हैं main।

Ungolfed 9 = (बाईं ओर की समस्या के कारण वर्ण, बाईं ओर की बाइट को नहीं छोड़ रहा है। इसलिए, मैं अब करता हूं mod (256)। सही पारी पहले की तुलना में परिणामी संख्या को थोड़ा कम कर देगी, इसलिए modदाएं शिफ्ट पर उपयोग करने की कोई आवश्यकता नहीं है । मेरी भोली-भाली चीज अंतिम 4 बिट्स और दूसरी-आखिरी कुतरने वाली चीज को स्वैप करेगी, और and (&)अन्य सभी बिट्स को रौंद देगी । मेरा उलटा प्रोग्राम मूल संख्या 256 से कम होने पर किसी भी समस्या का कारण नहीं बनता है।

बहुत से तीखे बयानों को बयान में बदलकर @Geobits के लिए 31 35 चार्ट बनाए गए switch, और शाब्दिक रूप से शॉर्ट्स को छोटा करते हुए चार्ट को परिवर्तित किया।

अनावश्यक हटाने के द्वारा 7 वर्ण golfed &240(निबल स्वैप में (a&240)>>4करने के लिए a>>4और परिवर्तित (a&15)<<4करने के लिए a<<4&240। अंतिम परिवर्तन केवल एक वर्ण हालांकि golfed।

=में अनावश्यक को हटाकर 1 char को गोल्फ किया जाता है a /= 2, क्योंकि a = a /= 2इसके बराबर है a = a / 2।

बदल कर 2 वर्ण golfed printlnलिए print।

आकस्मिक निकाल कर 2 वर्ण golfed a=में a=255-a( a=a=255-aके बराबर है a=255-a)

a<<4&240में बदल कर 1 चाक किया a%16<<4।

टेर्नेरी स्टेटमेंट के बाहर कोष्ठक को जोड़ने और करने के द्वारा 1 चार्ट को गोल्फ किया गया %256। इस तरह, %16निबल स्वैप के बाएं-शिफ्ट भाग में अनावश्यक है। कोष्ठक 2 वर्ण जोड़ते हैं और %163 वर्ण सहेजते हैं।

बदलकर 3 वर्ण golfed classकरने interfaceऔर हटाने publicजावा 8 के स्थिर इंटरफ़ेस विधि सुविधा का उपयोग कर। @TheNumberOne के लिए धन्यवाद (कोई टिप्पणी नहीं, लेकिन "जावा में गोल्फ के लिए टिप्स" पर उनका जवाब ढूंढें)

Comments

मुझे नहीं लगता कि वर्ग को सार्वजनिक होना चाहिए। इसके अलावा, मुझे लगता है कि अगर आप एक पूर्णांक के बजाय एक एक पूर्णांक बनाने के लिए, आप a.parseInt, a.toString, आदि के बजाय Integer.parseInt, Integer.toString, आदि कर सकता है

— bmarks

पहले सुझाव के लिए धन्यवाद; मैं Integerहालांकि सभी वर्ग विधियों को हटाने जा रहा हूं ।

— हाइपरएन्यूट्रीनो

शायद आप बाइट बचाने के लिए (i = System.in.read ())> 10) के बजाय (! 10) कर सकते हैं?

— हस्ताक्षर

अच्छा विचार है, लेकिन फिर 10 से नीचे कुछ भी कार्यक्रम को समाप्त करने का कारण होगा, और मुझे अन्य पात्रों को अनदेखा करना चाहिए, न कि तब दुनिया का अंत (या कम से कम मेरा कार्यक्रम :)) मैं इस पर विचार करूंगा; शायद 10. के नीचे कोई वैध

— एससीआई

यह लगभग कभी नहीं लायक है, switchजबकि थोड़ी देर गोल्फ का उपयोग करें । case/ breakबस बहुत लंबे हैं। आपको पूरी चीज को एक टर्नरी बनाकर एक गुच्छा को बचाने में सक्षम होना चाहिए; कुछ इस तरहa=i=='!'?255-a:i==62?a/2:i=='<'?a*2%256:i=='@'?(a&240)>>4|(a&15)<<4:a;

— Geobits

Answer 7

जंग, 121 115 बाइट्स

fn r(s:&str)->u8{let mut n=0u8;for t in s.chars(){match t{'!'=>n=!n,'>'=>n/=2,'<'=>n<<=1,'@'=>n=n>>4|n<<4,_=>()}}n}

नमूना रन:

fn main() {
    println!("{}", r("!"));    //=> 255
    println!("{}", r("!>>"));  //=> 63
    println!("{}", r("!<@"));  //=> 239
}

Ungolfed:

fn run_ungolfed(s: &str) -> u8 {
    let mut n = 0u8;
    for t in s.chars() {
        match t {
            '!' => n = !n,
            '>' => n >>= 1,
            '<' => n <<= 1,
            '@' => n = (n >> 4) | (n & 15) << 4,
            _ => ()
        }
    }
    n
}

आश्चर्यजनक रूप से जंग के लिए कम। इस तथ्य के अलावा और कुछ भी वास्तव में दिलचस्प नहीं है कि मैंने आज और अधिक पूर्वता के नियम सीखे - जो जानता था कि (a>>b)|cजैसा है वैसा ही है a>>b|c?

को बदलकर एक बाइट को शेव n>>=1किया n/=2; हालाँकि, एक ही गुणन के साथ नहीं किया जा सकता है, क्योंकि अंकगणित अतिप्रवाह एक जंग है (यानी दुर्घटना)।

Comments

जब आप अपने आप को समझाने कि पूर्वता बात समझ में आता है >>है प्रकार विभाजन की तरह के और |है प्रकार इसके अलावा तरह की।

— लिन

Answer 8

एचपी 41 सी / सीवी / सीएक्स (बाइट्स, 42 कदम)

पूरी तरह से गिगल्स के लिए, यहां यह एचपी 41 सी / सीवी / सीएक्स कैलकुलेटर के लिए है। (या तो विस्तारित फ़ंक्शंस मॉड्यूल की आवश्यकता होती है, या ATOX फ़ंक्शन के लिए 41CX।) कैलकुलेटर दुर्भाग्य से प्रोग्राम के आकार को बाइट्स में रिपोर्ट नहीं करता है।

अपने प्रोग्राम को अल्फा रजिस्टर में डालें, जो थोड़ा मुश्किल है, क्योंकि इसमें प्रवेश करने का कोई तरीका नहीं है! या कीबोर्ड से सीधे (XCA का उपयोग ASCII कोड 33 और 64 क्रमशः उन्हें जोड़ने के लिए)।

चरण 08 और 10 अमान्य opcodes की अनदेखी के लिए अनुमति देते हैं; उन्हें 2 चरणों को बचाने के लिए निकालें, लेकिन प्रोग्राम अमान्य इनपुट पर क्रैश हो जाएगा।

01 LBL"BB
02 0
03 LBL A
04 ATOX
05 X=0?
06 GTO E
07 X<>Y
08 SF 25
09 XEQ IND Y
10 CF 25
11 GTO A
12 LBL 33
13 255
14 X<>Y
15 -
16 RTN
17 LBL 60
18 2
19 *
20 256
21 MOD
22 RTN
23 LBL 62
24 2
25 /
26 INT
27 RTN
28 LBL 64
29 RCL X
30 16
31 /
32 INT
33 X<>Y
34 16
35 *
36 256
37 MOD
38 +
39 RTN
40 LBL E
41 RDN
42 RTN

Answer 9

पायथन 2, 79 बाइट्स

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

a=0
for i in raw_input():a=[~a,a/2,a*2,a*16+a/16,a]["!><@".find(i)]&255
print a

रूबी संस्करण से अंतर यह है कि यह इनपुट पर पुनरावृत्ति करते समय अमान्य निर्देशों की अनदेखी नहीं करता है। इसके बजाय मैं इस तथ्य का लाभ उठाता हूं कि जब कोई मैच नहीं होता है -1, nilतो पायथन वापस लौट जाता है - वर्तमान मान aको परिणाम सरणी के पीछे जोड़ दिया जाता है, ताकि सभी अमान्य निर्देश उसी, अपरिवर्तित मान पर मैप करें।

Answer 10

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

a=0
for i in input():
 if i in"!><@":a=(i=='!')*(255-a)+(i==">")*a//2+(i=="<")*(a+a)%256+(i=="@")*(16*(a%16)+a//16)
print(a)

"!" 255 से घटाया जा रहा है।
"<" 2 से गुणा करने के समान है। लेकिन 8 बिट रजिस्टर का मतलब mod 256 है।
">" पूर्णांक विभाजन के रूप में 2 से ही है।
"@" का अर्थ है 4 बिट्स ( a%16) द्वारा अंतिम स्थानांतरण *16) और पहले चार बिट्स ( a/16) को जोड़ना ।

EDIT (बेशर्म नकल पढ़ें)
अजगर में दूसरा जवाब (बीटा क्षय द्वारा ) देखा। शब्दकोश का उपयोग करके स्विच मामलों को अनुकरण करने के लिए यह वास्तव में प्रभावी तरीका है। जिसका उपयोग करके हम लिख सकते हैं

a=0
for i in input():a={"!":255-a,"<":a<<1&255,">":a//2,"@":(a%16)<<4+a>>4}.get(i,a)
print(a)

धन्यवाद, बीटा क्षय।

Comments

कोई फर्क नहीं पड़ता कि आप क्या ऑपरेशन करते हैं, आपको आधुनिक 256अधिकार को कम करना होगा? तो अंत में ऐसा क्यों न करें a={"!":255-a,"<":a*2,">":a//2,"@":(a%16)<<4+a>>4}.get(i,a)%256:। यह आपको तुरंत एक बाइट बचाता है (क्योंकि आप a*2इसके बजाय करेंगे a<<1) ... लेकिन @ डानिएरो के जवाब से यह भी पता चलता है कि अगर आप इसे इस तरह से करते हैं तो आपको (a%16)<<4बस छोटा किया जा सकता है a<<4, क्योंकि आपके द्वारा गुणा करने पर कोई भी बिट 16 या बड़ा समाप्त हो जाएगा यह 16 से और यह कम 256 mod। अच्छा! इसके अलावा, आप अब ... 255-aद्वारा -1-aया बेहतर द्वारा प्रतिस्थापित कर सकते हैं ~a। कुल मिलाकर, इन सुझावों से आपको 9 बाइट्स बचानी चाहिए।

— मैथमैडान

Answer 11

हास्केल, 89 बाइट्स

a#'!'=255-a
a#'>'=div a 2
a#'<'=mod(a*2)256
a#'@'=mod(a*16)256+div a 16
a#_=a
f=foldl(#)0

उपयोग उदाहरण: f "!>>"->63

Answer 12

जंग, 111 बाइट्स

@ Doorknob के उत्तर पर एक टिप्पणी के अधिक, लेकिन मेरे पास कोई टिप्पणी नहीं है क्योंकि मैंने अभी एक खाता बनाया है।

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

fn r(s:&str)->u8{let mut n=0u8;for t in s.chars(){n=match t{'!'=>!n,'>'=>n>>1,'<'=>n<<1,'@'=>n>>4|n<<4,_=>n}}n}

Comments

मुझे लगा कि हम फोल्ड ( doc.rust-lang.org/std/iter/trait.Iterator.html#method.fold ) का उपयोग करके और भी छोटे हो सकते हैं, लेकिन आश्चर्यजनक रूप से यह एक लंबे समय तक बनाता है।

— user4867444

Answer 13

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

संपादित करें: शॉर्टिंग, धन्यवाद @ जाकुब

Edit2: ठीक है, धन्यवाद @Anachor

a=0
for i in input():a=(a^255if i=="!"else a>>1if i==">"else a<<1if i=="<"else(a&15)<<4|(a&240)>>4if i=="@"else a)&255
print(a)

Comments

शायद ऐसा इसलिए है क्योंकि विंडोज़ की नई लाइन। वह प्लस टू बाइट्स है। मैं अगली बार उस बाइट काउंटर का उपयोग करूंगा। :-) धन्यवाद।

— uno20001

ध्यान दें कि शिफ्टिंग के दौरान यह सबसे बाईं ओर से !<510254

— हटता

मुझे उम्मीद है कि अब यह करता है। मेरी गलतियों के लिए क्षमा करें, यह मेरी पहली "गोल्फ" चुनौती है।

— uno20001

Answer 14

सीलोन, 297 290

shared void y(){value t=process.readLine()else"";variable Byte a=0.byte;for(c in t){switch(c)case('!'){a=a.not;}case('>'){a=a.rightLogicalShift(1);}case('<'){a=a.leftLogicalShift(1);}case('@'){a=a.and(#f0.byte).rightLogicalShift(4).xor(a.and(#f.byte).leftLogicalShift(4));}else{}}print(a);}

प्रारूपित:

shared void y() {
    value t = process.readLine() else "";
    variable Byte a = 0.byte;
    for (c in t) { switch (c)
        case ('!') { a = a.not; }
        case ('>') { a = a.rightLogicalShift(1); }
        case ('<') { a = a.leftLogicalShift(1); }
        case ('@') { a = a.and(#f0.byte).rightLogicalShift(4).xor(a.and(#f.byte).leftLogicalShift(4)); }
        else {} }
    print(a);
}

#fऔर #f0निबल्स के लिए हेक्साडेसिमल नंबर हैं, .byteएक पूर्णांक को बाइट में परिवर्तित करता है। मैं भाग्यशाली हूं कि बाइट की .stringविशेषता पहले से ही बाइट के अहस्ताक्षरित प्रतिनिधित्व का उपयोग करती है। सीलोन में गिरावट के बिना एक स्विच स्टेटमेंट भी है, और एक स्ट्रिंग पात्रों की एक सूची है, जिसे पुनरावृत्त किया जा सकता है।

मैंने अलियासिंग आयात का उपयोग करके उन लंबी शिफ्ट विधि नामों को काटने की भी कोशिश की, लेकिन यह वास्तव में 7 बाइट्स लंबा हो जाता है:

import ceylon.language{Byte{r=rightLogicalShift,l=leftLogicalShift}}shared void x(){value t=process.readLine()else"";variable Byte a=0.byte;for(c in t){switch(c)case('!'){a=a.not;}case('>'){a=a.r(1);}case('<'){a=a.l(1);}case('@'){a=a.and(#f0.byte).r(4).xor(a.and(#f.byte).l(4));}else{}}print(a);}

प्रारूपित:

import ceylon.language {
    Byte {
        r=rightLogicalShift,
        l=leftLogicalShift
    }
}
shared void x() {
    value t = process.readLine() else "";
    variable Byte a = 0.byte;
    for (c in t) {
        switch (c)
        case ('!') { a = a.not; }
        case ('>') { a = a.r(1); }
        case ('<') { a = a.l(1); }
        case ('@') { a = a.and(#f0.byte).r(4).xor(a.and(#f.byte).l(4)); }
        else {}
    }
    print(a);
}

यह उपयोगी हो सकता है अगर हमें उन तरीकों की थोड़ी अधिक आवश्यकता हो।

Answer 15

माणिक, 81 73 बाइट्स

इतना सरल - कोई सबूत नहीं! इनपुट में प्रत्येक वैध चरित्र के लिए, यह प्रत्येक निर्देश का मूल्यांकन करता है, और $&(इनपुट में वर्तमान चरित्र) के सूचकांक के माध्यम से उचित निर्देश पाता है ।

a=0
gets.scan(/[!><@]/){a=[~a,a/2,a*2,a*16+a/16]["!><@".index$&]&255}
p a

Comments

वह जीनियस है। बहुत छोटा है कि किसी भी तरह से। मेरे द्वारा 2 उत्थान!

— edc65

आप कैसे दोहरा सकते हैं ...?

— हाइपरनेत्रिनो

@JamesSmith वह शायद इस और मेरे अजगर जवाब का जिक्र कर रहे हैं :)

— daniero

@danerio मैं देखता हूं।

— हाइपरएन्यूट्रीनो

Answer 16

STATA, 197 बाइट्स

di _r(a)
gl b=0
forv x=1/`=length("$a")'{
gl c=substr("$a",`x',1)
if"$c"=="!" gl b=255-$b
if"$c"==">" gl b=int($b/2)
if"$c"=="<" gl b=mod($b*2,256)
if"$c"=="@" gl b=mod($b,16)*16+int($b/16)
}
di $b

Ungolfed

display _request(a) //get the input via prompt and put in var a
global b=0 //initialise A to be 0
forv x=1/`=length("$a")'{ //for loop from 1 to last char in a
global c=substr("$a",`x',1) //get the char at index x in a
if "$c"=="!" global b=255-$b //invert is the same as 255-A
if "$c"==">" global b=int($b/2) //right shift is the same as A/2 (with integer division)
if "$c"=="<" global b=mod($b*2,256) //left shift is the same as A*2%256
if "$c"=="@" global b=mod($b,16)*16+int($b/16) //nibble swap is the same as A%16*16+A/16
}
display $b //display the result of A

ऑनलाइन दुभाषिया के साथ काम नहीं करता है और गैर-मुक्त डिफ़ॉल्ट दुभाषिया की आवश्यकता होती है। यह वास्तविक बिटवाइज़ ऑपरेशंस के साथ कुछ आसान होगा, लेकिन मुझे नहीं लगता कि वे STATA के अधिकांश सामान्य उपयोगों के लिए बहुत उपयोगी हैं।

Comments

ऑनलाइन दुभाषिया काम क्यों नहीं करता है?

— कैलक्यूलेटरफैनलाइन

Answer 17

जावास्क्रिप्ट, 104

[].reduce.call(prompt(),function(a,i){return(i=='!'?~a:i=='>'?a/2:i=='<'?a*2:i=='@'?a>>4|a<<4:a)&255},0)

नेस्टेड टर्नरी ऑपरेटर निर्देशों के लिए मैप करते हैं।

BITWISE AND का उपयोग हमारी संख्या प्रकार को एक बाइट के लिए बाध्य करने के लिए किया जाता है।

Answer 18

जूलिया, 117 94 86 73 बाइट्स

p->(a=0x0;[a=c==33?~a:c==60?a<<1:c==62?a>>1:c!=64?a:a<<4|a>>4for c=p];1a)

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

Ungolfed:

function f(p)
    # Initialize the accumulator to 0 as an 8-bit unsigned integer
    a = 0x0

    # Loop over the characters in the input
    for c in p
        a = c == 33 ? ~ a :        # '!'
            c == 60 ? a << 1 :     # '<'
            c == 62 ? a >> 1 :     # '>'
            c != 64 ? a :          # no-op
            a << 4 | a >> 4        # '@'
    end

    # Convert the accumulator to a regular integer and return
    return Int(a)
end

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

Answer 19

जावास्क्रिप्ट (ईएस 6), 76 81

एक अनाम फ़ंक्शन के रूप में संचायक मान लौटाता है

यह @daniero द्वारा सुपर चतुर उत्तरों का एक पोर्टिंग है (जो कि बहुत कम अपवोट करता है)

बोनस: आप संचायक का एक प्रारंभिक मूल्य पारित कर सकते हैं। यदि उत्तीर्ण नहीं है, तो विशिष्ट के रूप में मूल्य 0 होना शुरू होता है।

(p,a)=>(p.replace(/[!<>@]/g,i=>a=(i<'<'?~a:i<'>'?a*2:i<'@'?a/2:a*257/16)&255),a)

किसी भी EcmaScript 6 ब्राउज़र में नीचे स्निपेट का परीक्षण करना (मैंने फ़ायरफ़ॉक्स में परीक्षण किया)

f=(p,a)=>[...p].map(c=>a=255&[a,~a,a*2,a/2,a*257/16][1+'!<>@'.indexOf(c)])|a

// TEST
out=x=>O.innerHTML+=x+'\n'

function go(x) { out(x+' -> '+f(x)) }

go('!'),go('!>>'),go('!<@'),go('!nop!&6*!')

// LESS GOLFED
F=(p,a)=>// a as a parameter, if not passed its value starts as undefined, then becomes NaN, but the operators '&' and '~' treat it as 0
  [...p].map(c => // execute following function for each character p
    a = 255 & // any intermediate result is converted to numeric and truncate to a byte          
   // evaluate all possible results (then choose one bases on the current character)
   [a,   // NOP, if unexpected char 'a' remains the same
    ~a,  // tilde == binary not (will give a result wider than a byte)
    a*2, // < shift left is *2 (can give a result wider than a byte) 
    a/2, // > shift right is /2 (can give a non integer result)
    a *257 / 16  // move nibbles around (will give a result wider than a byte)
   ] // array of all results
   [1+'!<>@'.indexOf(c)] // find index to get the correct result
  ) // end map, returns an array in any case
    // eventually a single element array containg a
  | a // return accumulator

Test program:<input id=I><button onclick='go(I.value)'>go</button>
<pre id=O></pre>

Answer 20

क्रिस्टल, 139 बाइट्स

def f x
b=0_u8
x.chars.each do|c|
b=case c
when'!'
~b
when'>'
b>>1
when'<'
b<<1
when'@'
b<<4|b>>4
else raise ""
end
end
puts b
end

Answer 21

C # 193

void Main(){byte a=0;foreach(var c in Console.ReadLine()){if(c=='!')a=(byte)~a;if(c=='>')a=(byte)(a>>1);if(c=='<')a=(byte)(a<<1);if(c=='@')a=(byte)(((a&240)>>4)|((a&15)<<4));}Console.Write(a);}

Comments

आपको उपसर्ग के बिना और using System;एक्सेस करने की आवश्यकता नहीं है ? Console.ReadLineConsole.WriteSystem.

— एलेक्स ए।

यह भी मुझे लगता है कि आपको byteप्रत्येक ऑपरेशन के लिए नहीं डालना चाहिए, लेकिन मैं गलत हो सकता है।

— एलेक्स ए।

Answer 22

लुआ, 344 चार

a=string.rep("0",8)
t=io.read()
f={["!"]=function()local s="";for j=1,8 do s=s..(a:sub(j,j)=="0"and"1"or"0") end;return s end,[">"]=function() return "0"..a:sub(1,7) end,["<"]=function()return a:sub(2,8).."0"end,["@"]=function()return a:sub(5,8)..a:sub(1,4)end}
for i=1,#t do a=(f[t:sub(i,i)]or function()return a end)()end
print(tonumber(a,2))

@Beta डेके द्वारा एक स्ट्रिंग संचायक के उपयोग से प्रेरित होकर, यह देखते हुए कि लुआ के पास कोई बाइट प्रकार नहीं है। शायद कम फ़ंक्शन का उपयोग करके अधिक गोल्फ हो सकता है।

Answer 23

आर, 194 बाइट्स

b<-readline();A<-rep(0,8);s<-strsplit(b,"")[[1]];for(r in s){if(r=="!")A<-(A+1)%%2;if(r==">")A<-c(0,A)[1:length(A)];if(r=="<")A<-c(A,0)[-1];if(r=="@")A<-c(A[5:8],A[1:4])};print(sum(A*(2^(7:0))))

ungolfed

b <- readline()
A <- rep(0, 8) 
s <- strsplit(b, "")[[1]]
for (r in s) {
    if (r == "!")
        A <- (A + 1) %% 2
    if (r == ">")
        A <- c(0, A)[1:length(A)]
    if (r == "<")
        A <- c(A, 0)[-1]
    if (r == "@")
        A <- c(A[5:8], A[1:4])
}
print(sum(A*(2^(7:0))))

Comments

सभी को <-यहां से बदला जा सकता =है, इस प्रकार कोड को 7 बाइट्स से कम किया जा सकता है । इसके अतिरिक्त आप ifबयानों की श्रृंखला को एक कॉल से switch(जैसे A=switch(r,"!"=(A+1)%%2, ...)) में बदल सकते हैं

— प्लेनैपस

परिणामस्वरूप b=readline();A=rep(0,8);s=strsplit(b,"")[[1]];for(r in s)A=switch(r,"!"=(A+1)%%2,">"=c(0,A)[1:length(A)],"<"=c(A,0)[-1],"@"=c(A[5:8],A[1:4]),A);print(sum(A*(2^(7:0))))167 बाइट्स हैं।

— प्लेनैपस

Answer 24

आरपीएल, 170.5 बाइट्स

इनपुट को स्तर 1 पर एक स्ट्रिंग के रूप में दर्ज किया जाना चाहिए।

\<< DEC 8 STWS \-> S 
    \<< #0d 1 S SIZE 
        FOR I "!><@" S I DUP SUB POS 1 + { \<< \>> NOT SR SL \<< DUP #16d / SWAP #16d * + \>> } SWAP GET EVAL NEXT \>> 
\>>

Answer 25

के, 57 बाइट्स

यह एक शुरुआत है:

0{y+2*x}/(8#0){((~:;{-1_0,x};{1_ x,0};4!;{x})"!><@"?y)x}/

परीक्षण का उपयोग कर Kona:

  f:0{y+2*x}/(8#0){((~:;{-1_0,x};{1_ x,0};4!;{x})"!><@"?y)x}/
...
  f'("!";"!>>";"!<@";"!nop!&6*!")
255 63 239 255

मैं k5 में बेहतर करने में सक्षम हो सकता हूं, लेकिन यह ट्रेडऑफ की एक जटिल श्रृंखला है- उदाहरण के लिए, बाइनरी को दशमलव में परिवर्तित करना उतना ही आसान है 2/, लेकिन ?अनुदेश देखने के लिए एक डिफ़ॉल्ट मामले को संभालने के लिए कठिन व्यवहार करता है।

Answer 26

PHP, 189 बाइट्स

<? $c='00000000';foreach(str_split($argv[1])as$a){$a=='!'&&$c=strtr($c,'01','10');$a=='<'&&$c=substr($c.'0',1);$a=='>'&&$c=substr('0'.$c,0,8);$a=='@'&&$c=substr($c.$c,4,8);}echo bindec($c);

ऐसा नहीं है कि यह कई उत्तरों को हरा देगा, यह केवल अभ्यास के लिए है

Answer 27

एचपीपीपीएल , 302 294 बाइट्स

#pragma mode(separator(.,;)integer(d8))EXPORT b()BEGIN print();local p,j,a;a:=#0d;INPUT({{p,[2]}});for j from 1 to dim(p)do c:=p(j);case if c==33 then a:=BITNOT(a)end if c==62 then a:=BITSR(a,1)end if c==60 then a:=BITSL(a,1)end if c==64 then a:=BITSL(a,4)+BITSR(a,4)end end;end;print(a*1);END;

Ungolfed:

// make sure integers are unsigned 8 bit decimal numbers
#pragma mode( separator(.,;) integer(d8) ) 
EXPORT b()
BEGIN
  print();
  local p,j,a;
  a:=#0d;                         // set a to integer value 0
  INPUT({{p,[2]}});               // open input dialog treating input as string ( type [2])
  for j from 1 to dim(p) do
    c:=p(j);
    case
      if c==33 then a:=BITNOT(a) end             // !
      if c==62 then a:=BITSR(a,1) end            // >
      if c==60 then a:=BITSL(a,1) end            // <
      if c==64 then a:=BITSL(a,4)+BITSR(a,4) end // @
    end;
  end;
  print(a*1); // converts to proper output by promoting to non integer format
              // print(a) would result in
              // #239:8d for 239 if the default bit size is not set to 8 bits decimal
              // indicating an 8 bit unsigned decimal integer, or
              // #239d if the default bit size is already set to 8 bits decimal

END;

यह उत्तर सुनिश्चित करता है कि उपयोगकर्ता द्वारा 64 बिट्स के लिए मोड सेट किए जाने पर भी HP Prime अहस्ताक्षरित 8 बिट पूर्णांक का उपयोग करता है। यदि अहस्ताक्षरित 8 बिट दशमलव पूर्णांक का उपयोग करने के लिए कैलकुलेटर को मैन्युअल रूप से सेट किया गया है, तो pragmaकमांड को छोड़ा जा सकता है। यदि आउटपुट को प्रारूप का कड़ाई से पालन करने की आवश्यकता नहीं है a*1, तो अंत में बस हो सकता है a। परिणाम को 1 से गुणा करना सुनिश्चित करता है कि आउटपुट पूर्णांक मानों के लिए आंतरिक आउटपुट का पालन नहीं करता है। printयदि टर्मिनल परिणाम बाहर मुद्रण से पहले साफ करने की आवश्यकता नहीं है लाइन 4 में आदेश भी छोड़ा जा सकता है। यदि प्रोग्राम को स्ट्रिंग तर्क के रूप में पारित करने की अनुमति है, तो INPUTकमांड को भी छोड़ा जा सकता है।

यह इनपुट और उचित आउटपुट के साथ सबसे छोटा संस्करण है, बिना प्रोगाम तर्क के (यदि कैलकुलेटर डिफ़ॉल्ट रूप से Uint8 पर सेट है:

243 बाइट्स:

EXPORT b()BEGIN local p,j,a;a:=#0d;INPUT({{p,[2]}});for j from 1 to dim(p)do c:=p(j);case if c=33 then a:=BITNOT(a)end if c=62 then a:=BITSR(a,1)end if c=60 then a:=BITSL(a,1)end if c=64 then a:=BITSL(a,4)+BITSR(a,4)end end;end;print(a*1);END;

Answer 28

पर्ल 6, 96 89 बाइट्स

{my $a=0;$a=(+^*,*+<1,*+>1,{$_+<4+$_+>4},{$_})["!<>@".index($_)//4]($a)%256 for .comb;$a}

पुराना समाधान:

{my $a=0;$a=(255-*,*+<1+&255,*+>1,{$_+&15+<4+$_+>4},{$_})["!<>@".index($_)//4]($a)for .comb;$a}

Answer 29

सी #, 119 बाइट्स

i=>{var a=0;foreach(var c in i){if(c=='!')a=~a;if(c=='>')a>>=1;if(c=='<')a<<=1;if(c=='@')a=a<<4|a>>4;a&=255;}return a;}

मैंने कोशिश की अन्य संस्करणों, लेकिन अधिक बाइट्स की जरूरत है:

Func<string,int>C=i=>{var a=0;foreach(var c in i){switch(c){case'!':a=~a;break;case'<':a<<=1;break;case'>':a>>=1;break;case'@':a=a<<4|a>>4;break;}a&=255;}return a;};

// This is, despite having the worst score, my personal favourite :D
Func<string,int>D=i=>{var f=new Dictionary<char,Func<int,int>>{{'!',q=>~q},{'<',q=>q<<1},{'>',q=>q>>1},{'@',q=>q<<4|q>>4}};var a=0;foreach(var c in i)if(f.ContainsKey(c))a=f[c](a)&255;return a;};

Answer 30

पायथन 2.7.3, 104 बाइट्स

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

a=0
for c in raw_input():a=eval({'!':'~a','<':'a<<1','>':'a>>1','@':'a<<4|a>>4'}.get(c,'a'))&255
print a

यहाँ उत्पादन (और इनपुट वास्तव में है ..)

और हाँ, यह वास्तव में एक रास्पबेरीपी पर चल रहा है :)