एक कैमरा घुमाएं; एक अंतरिक्ष यात्री को बचाओ

23

नोट: द मार्टियन के लिए माइनर स्पॉइलर इस चुनौती में हैं। आगे पढ़ें सावधानी के साथ

द मार्टियन एक साइंस फिक्शन उपन्यास है , जो अंतरिक्ष यात्री और वनस्पति विज्ञानी असाधारण, मार्क वाटनी के बारे में है , जो गलती से मंगल पर फंसे हुए हैं। पुस्तक के एक बिंदु पर, मार्क नासा के साथ संचार करने की कोशिश करता है, लेकिन संचार का एकमात्र साधन उनके पास एक कैमरा है। मार्क इंडेक्स कार्ड्स पर लिखकर संदेश भेजता है, और, चूंकि नासा कैमरा 360 डिग्री घूम सकता है, इसलिए नासा "हां" या "नहीं" लेबल वाले कार्ड पर कैमरे को इंगित करके उत्तर भेजता है।

चूंकि NASA जो एकमात्र डेटा भेज सकता है, वह वह दिशा है, जिसका कैमरा सामना कर रहा है, मार्क एक प्रणाली लेकर आता है, जहाँ वे संदेशों को टाइप करने के लिए उन पर वर्णमाला वर्णों वाले कार्डों को इंगित कर सकते हैं। लेकिन 'az' अक्षर का प्रयोग अव्यवहारिक होगा। पुस्तक उद्धृत करने के लिए ( इस उत्तर से , scifi.se पर):

हमें हर आधे घंटे में हां / ना के सवालों से तेज बात करनी होगी। कैमरा 360 डिग्री घूम सकता है, और मेरे पास बहुत सारे एंटीना पार्ट्स हैं। एक वर्णमाला बनाने का समय। लेकिन मैं सिर्फ Z. ट्वेंटी-लेटर के माध्यम से A अक्षर का उपयोग नहीं कर सकता हूं, साथ ही मेरा प्रश्न पत्र लैंडर के आसपास सत्ताईस कार्ड होगा। हर एक को केवल 13 डिग्री चाप मिलेगा। यहां तक ​​कि अगर JPL पूरी तरह से कैमरे को इंगित करता है, तो एक अच्छा मौका है मुझे पता नहीं होगा कि वे किस पत्र का मतलब है।

इसलिए मुझे ASCII का उपयोग करना होगा। इस तरह से कंप्यूटर वर्णों का प्रबंधन करते हैं। प्रत्येक वर्ण में 0 और 255 के बीच एक संख्यात्मक कोड होता है। 0 और 255 के बीच के मान 2 हेक्साडेसिमल अंकों के रूप में व्यक्त किए जा सकते हैं। मुझे हेक्स अंकों के जोड़े देकर, वे किसी भी वर्ण को भेज सकते हैं, जैसे कि संख्या, विराम चिह्न आदि।

...

तो मैं 9 के माध्यम से 0 के लिए कार्ड बनाता हूं, और ए के माध्यम से एफ। यह 16 कार्ड को कैमरे के चारों ओर जगह बनाने के लिए बनाता है, साथ ही प्रश्न कार्ड। सत्रह कार्ड का मतलब 21 डिग्री से अधिक है। बहुत आसान से निपटने के लिए।

आपका लक्ष्य आज, नासा के शीर्ष सॉफ्टवेयर इंजीनियरों में से एक के रूप में, कैमरे के विभिन्न कोणों को एनकोड करने के लिए एक कार्यक्रम लिखना है। आपके द्वारा इंगित करने के लिए मार्क के सत्रह कार्ड हैं (क्रम में):

?0123456789ABCDEF

और इन कार्डों में से प्रत्येक के इतने से कैमरे को घुमाने के लिए 21 डिग्री के अलावा है, ?करने के लिए 0, आप कैमरा 21 डिग्री बारी बारी से करना चाहिए, और 2करने के लिए 1-21 डिग्री है। (यह बिल्कुल 21 नहीं है , लेकिन हम इसे सरल रखने के लिए गोल करेंगे) यह लपेटता है, इसलिए से जाने के Fलिए 3105 डिग्री (5 मोड़, 5 * 21 = 105) है। यह -252 से अधिक कुशल है, क्योंकि कैमरा को अधिक दूर नहीं जाना होगा।

यहां बताया गया है कि आपका प्रोग्राम या फंक्शन क्या करना चाहिए।

  1. इनपुट के रूप में एक स्ट्रिंग लें। हम इस स्ट्रिंग फोन करता हूँ रों । इसे सरल रखने के लिए, हम कहेंगे कि इनपुट केवल मुद्रण योग्य ASCII होगा। हमारे उदाहरण के लिए, मान लें कि इनपुट थाSTATUS

  2. प्रत्येक चरित्र को उसके हेक्साडेसिमल प्रतिनिधित्व में बदलें। यह बदल जाएगा STATUSकरने के लिए 53 54 41 54 55 53।

  3. प्रिंट आउट या रिटर्न लगातार डिग्री बदल जाता है कैमरा को प्रत्येक कार्ड पर इंगित करने और "प्रश्न कार्ड" पर लौटने की आवश्यकता होगी। हमारे उदाहरण के लिए, यह होगा:

    6  * 21 = 126   (?-5)
-2 * 21 = -42   (5-3)
2  * 21 = 42    (3-5)
-1 * 21 = -21   (5-4)
0  * 21 = 0     (4-4)
-3 * 21 = -63   (4-1)
4  * 21 = 84    (1-5)
-1 * 21 = -21   (5-4)
1  * 21 = 21    (4-4)
0  * 21 = 0     (5-5)
0  * 21 = 0     (5-5)
-2 * 21 = -42   (5-3)
-4 * 21 = -84   (3-?)

    या, सरणी प्रारूप में:

    [126, -42, 42, -21, 0, -63, 84, -21, 21, 0, 0, -42, -84]

ध्यान दें कि आपको हमेशा संभव घुमावों में से सबसे छोटा लेना चाहिए। तो अगर इनपुट था NO, जो 4E 4F, आपको आउटपुट चाहिए:

5    * 21 = 105
-7   * 21 = -147
7    * 21 = 147
-6   * 21 = -126
1    * 21 = 21

बजाय:

 5   * 21 = 105
 10  * 21 = 210
 -10 * 21 = -210
 11  * 21 = 231
 -16 * 21 = -336

यहां कुछ और काम किए गए उदाहरण हैं:

Input: CROPS?
ASCII: 43 52 4F 50 53 3F
Worked Example:

5  * 21 = 105
-1 * 21 = -21
2  * 21 = 42
-3 * 21 = -63
2  * 21 = 42
-6 * 21 = -126
7  * 21 = 147
-5 * 21 = -105
5  * 21 = 105
-2 * 21 = -42
0  * 21 = 0
-5  * 21 = -105
1 * 21 = 21

Result: [105 -21 42 -63 42 -126 147 -105 105 -42 0 -105 21]


Input: DDD
ASCII: 44 44 44
Worked Example:

5   * 21 = 105
0   * 21 = 0
0   * 21 = 0
0   * 21 = 0
0   * 21 = 0
0   * 21 = 0
-5  * 21 = -105

Result: [105, 0, 0, 0, 0, 0, -105]


Input: Hello world!
ASCII: 48 65 6c 6c 6f 20 77 6f 72 6c 64 21
Worked example:

5   * 21 = 105
4   * 21 = 84
-2  * 21 = -42
-1  * 21 = -21
1   * 21 = 21
6   * 21 = 126
-6  * 21 = -126
6   * 21 = 126
-6  * 21 = -126
-8  * 21 = -168
4   * 21 = 84
-2  * 21 = -42
7   * 21 = 147
0   * 21 = 0
-1  * 21 = -21
-8  * 21 = -168
-8  * 21 = -168
-5  * 21 = -105
4   * 21 = 84
6   * 21 = 126
-6  * 21 = -126
-2  * 21 = -42
-2  * 21 = -42
-1  * 21 = -21
-2  * 21 = -42

Result: [105 84 -42 -21 21 126 -126 126 -126 -168 84 -42 147 0 -21 -168 -168 -105 84 126 -126 -42 -42 -21 -42]

चूंकि नासा दक्षता पर गर्व करता है, इसलिए आपका लक्ष्य सबसे छोटा कोड संभव लिखना है। मानक खामियां लागू होती हैं। अब उसे घर ले आओ!

code-golf  string  hexadecimal 
— DJMcMayhem
स्रोत
साइड नोट: ये परीक्षण मामले हाथ से बने थे, और एक तरह के दर्द थे, इसलिए कुछ मामूली अशुद्धियाँ हो सकती हैं। कृपया मुझे बताएं कि क्या कुछ गलत लगता है। :)
— DJMcMayhem
— डिजिटल ट्रॉमा

जवाबों:

5

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

s=>[...s.replace(/./g,c=>c.charCodeAt().toString(16)),10].map(n=>((24-p-~(p='0x'+n))%17-8)*21,p=-1)

परीक्षण के मामलों

कोड स्निपेट दिखाएं

— ETHproductions
स्रोत
क्या यह काम करेगा? s.replace(/./g,->[...s].map(
— ल्यूक
@ ल्यूक नॉप, क्योंकि हमें प्रत्येक हेक्साडेसिमल अंक को अलग करने की आवश्यकता है। ...s.replace(/./g,जैसे "4","8","6","5","6","c"..., जबकि देता है । ...[...s.map(देना होगा"48","65","6c",...
— ETHproductions
4

सी, 212 202 199 187 बाइट्स

3 बाइट्स ने @KritiiLithos को धन्यवाद बचाया!

i;f(a,b){i=abs(a-b);i=8>i?i:17-i;i=a<b&a>b-8?i:a<b&a<b-8?-i:b<a&b>a-8?-i:i;i*=21;}v;g(char*s){for(v=0;*s;s+=v++%2)printf("%d ",v?v%2?f(*s%16,s[1]?s[1]/16:-1):f(*s/16,*s%16):f(-1,*s/16));}

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

— betseg
स्रोत
1
मुझे लगता है कि आप 8>i?i:17-iइसके बजाय कर सकते हैं17-i>i?...
— क्रिति लिथोस
@ कृतिलीथोस यूप, धन्यवाद।
— betseg
3

पायथन, 187 178 बाइट्स

def g(x):w,z=map('?0123456789abcdef'.index,x);d=w-z;return min(d,d+17*(d<=0 or -1),key=abs)*21
def f(s):s=''.join(map('{:2x}'.format,s.encode()));return[*map(g,zip(s+'?','?'+s))]

परीक्षण के मामलों

for k in ['STATUS', 'NO', 'CROPS?', 'DDD', 'Hello world!']:
    print('Input:  {}\nOutput: {}'.format(k, f(k)))
— Uriel
स्रोत
1

जेली , 21 19 बाइट्स

Ob⁴F-;;-I+8%17_8×21

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

कैसे?

Ob⁴F-;;-I+8%17_8×21 - Main link: string s        e.g. 'e.g.'
O                   - cast to ordinals            [101,     46,       103,      46]
 b                  - convert to base
  ⁴                 -     16                   [[6,   5], [2,  14], [6,   7], [2,  14]]
   F                - flatten                   [6,   5,   2,  14,   6,   7,   2,  14]
    -;              - -1 concatenate      [-1,   6,   5,   2,  14,   6,   7,   2,  14]
      ;-            - concatenate -1      [-1,   6,   5,   2,  14,   6,   7,   2,  14,  -1]
        I           - increments            [  7,  -1,  -3,  12,  -8,   1,  -5,  12, -15]
         +8         - add 8                 [ 15,   7,   5,  20,   0,   9,   3,  20,  -7]
           %17      - mod 17                [ 15,   7,   5,   3,   0,   9,   3,   3,  10]
              _8    - subtract 8            [  7,  -1,  -3,  -5,  -8,   1,  -5,  -5,   2]
                ×21 - multiply by 21        [147, -21, -63,-105,-168,  21,-105,-105,  42]
— जोनाथन एलन
स्रोत
1

ओम , 20 19 बाइट्स (CP437), गैर-प्रतिस्पर्धात्मक

संपादित करें : एक एकल खंड को दोहराए गए एकल-घटक मानचित्रों में बदलकर 1 बाइट सहेजा गया।

अगर मैं अंतर्निहित वैश्वीकरण होता तो शायद काफी कम होता।

`»x»}{»úΓXΓHδ▓_~21*

स्पष्टीकरण:

`»x»}{»úΓXΓHδ▓_~21*    Main wire, arguments: s

`»x                    Convert char codes of s to hex
   »}                  Split digit pairs
     {                 Flatten
      »ú               Convert digits back to base 10
        ΓXΓH           Append and prepend with -1
            δ          Get deltas between each element of array
             ▓         Map array over...
              _~21*      Negate, multiply by 21
— निक क्लिफोर्ड
स्रोत
0

PHP, 125 116 बाइट्स:

function m($i){static$a;$a+=$d=($i-$a+10)%17-9;echo$d*21,"
";}for(;$c=ord($argv[1][$i++]);m($c%16))m($c/16|0);m(-1);

टूट - फूट

function m($i)              // function to turn camera:
{
    static$a;                   // remember angle
    $a+=                        // add delta to angle
    $d=($i-$a+10)%17-9;         // delta: target=nibble value+1-current angle
                                // add 9, modulo 17, -9 -> shortest movement
    echo$d*21,"\n";                 // print delta * 21 and a linebreak
}
for(;$c=ord($argv[1][$i++]);// loop through input characters
    m($c%16))                   // 2. move to low nibble value
    m($c/16|0)                  // 1. move to high nibble value
;
m(-1);                      // move back to "?"

बेशक, 21बहुत गलत है और 14 वर्णों से अधिक लंबे तार के लिए विफल हो सकता है; लेकिन फिर ... 360/17चार बाइट्स लंबा होगा।

एक वैकल्पिक समाधान एक लेजर पॉइंटर को कैमरे में संलग्न करना होता;
हम सभी प्रिंट करने योग्य एससीआई चार्ट और 3.75 डिग्री पर "प्रश्न" कार्ड का उपयोग कर सकते हैं।

एक अन्य विकल्प: 6 वर्णों के साथ 16 कार्ड (22.5 डिग्री पर) का उपयोग करें:
कुछ प्रकार के टी 9 को लागू करें और हम उच्च खिंचाव को छोड़ सकते हैं। ;)

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