कुक और व्हीटस्टोन टेलीग्राफ, पांच-सुई


20

परिभाषा

विकिपीडिया के अनुसार :

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

यह इस तरह काम करता है:

कुक और व्हीटस्टोन टेलीग्राफ की योजना, पांच-सुई

बीच में पाँच सुइयाँ होती हैं, जिन्हें दक्षिणावर्त विक्षेपित किया जा सकता है (जैसा कि मध्य सुई की स्थिति में होता है) या एंटी-क्लॉकवाइज़ (जैसा कि अंतिम सुई का मामला है)।

ऊपर की तस्वीर में, दो विक्षेपित सुइयां पत्र को इंगित करती हैं G, जिसका अर्थ है कि प्रेषित / प्राप्त किया जा रहा पत्र अक्षर है G

नोट पत्र है कि C, J,Q , V, X, Zयाद कर रहे हैं और इस प्रकार अन्य पत्र के साथ प्रतिस्थापित किया जाना है।

कार्य

आप ABDEFGHIKLMNOPRSTUWYइनपुट के रूप में एक चरित्र प्राप्त करेंगे, और आप पांच सुइयों के संबंधित विन्यास को आउटपुट करेंगे, जैसा कि अपरिभाषित है| , , जैसा कि घड़ी की दिशा में /विक्षेपित है, और एंटी- में विक्षेपित है \

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

इसमें सभी संभावित इनपुट शामिल हैं

input output
A     /|||\
B     /||\|
D     |/||\
E     /|\||
F     |/|\|
G     ||/|\  (explanation: see above)
H     /\|||
I     |/\||
K     ||/\|
L     |||/\
M     \/|||
N     |\/||
O     ||\/|
P     |||\/
R     \|/||
S     |\|/|
T     ||\|/
U     \||/|
W     |\||/
Y     \|||/

नियमों / आवश्यकताओं

  • प्रत्येक जमा या तो एक पूर्ण कार्यक्रम या फ़ंक्शन होना चाहिए। यदि यह एक फ़ंक्शन है, तो प्रोग्राम के निचले भाग में फ़ंक्शन कॉल को जोड़ने की आवश्यकता के द्वारा इसे चलाने योग्य होना चाहिए। कुछ भी (जैसे सी में हेडर), शामिल किया जाना चाहिए।
  • यदि यह संभव है, तो उस साइट का लिंक प्रदान करें जहां आपके कार्यक्रम का परीक्षण किया जा सकता है।
  • आपके प्रोग्राम को कुछ भी नहीं लिखना चाहिए STDERR
  • मानक ढीले निषिद्ध हैं।
  • आपका कार्यक्रम किसी भी मामले में आउटपुट कर सकता है, लेकिन इसे मुद्रित किया जाना चाहिए (सरणी या समान नहीं)।

स्कोरिंग

कार्यक्रम डिफ़ॉल्ट रूप से या अपनी पसंद के किसी भिन्न वर्ण सेट द्वारा UTF-8 में बाइट्स के अनुसार बनाए जाते हैं।

Eventuallyकम से कम बाइट के साथ जवाब जीत जाएगा।

प्रस्तुतियाँ

यह सुनिश्चित करने के लिए कि आपका उत्तर दिखाई देता है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

# Language Name, N bytes

Nआपके सबमिशन का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

# Ruby, <s>104</s> <s>101</s> 96 bytes

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फाइलों का योग है या आप दुभाषिया ध्वज दंड को अलग से सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक अंक अंतिम संख्या है:

# Perl, 43 + 2 (-p flag) = 45 bytes

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो लीडरबोर्ड स्निपेट में दिखाई देगा:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

लीडरबोर्ड

यहां एक नियमित लीडरबोर्ड और भाषा के अनुसार विजेताओं का अवलोकन करने के लिए एक स्टैक स्निपेट है।

जवाबों:


6

सी, 124 107 98 बाइट्स

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

x,i;W(char*v){for(i=strcspn(" MRUYH NSWEI OTBFK PADGL",v);x<5;++x)putchar(x^i%5?x^i/5?124:92:47);}

// main(int c,char**v){W(v[1]);}

यह ग्रिड 45 डिग्री को घुमाने और परिणामी ब्लॉक से पंक्ति / स्तंभ को देखकर काम करता है।


पूर्ण निष्पादन योग्य (107 बाइट्स) के रूप में:

x;main(i,v)char**v;{for(i=strcspn(" MRUYH NSWEI OTBFK PADGL",v[1]);x<5;++x)putchar(x^i%5?x^i/5?124:92:47);}

एक वैकल्पिक पूर्ण निष्पादन योग्य: (एक ही बाइटकाउंट लेकिन स्टड से इनपुट लेता है और इसमें आउटपुट के बाद न्यूलाइन शामिल है)

main(i){char*r=" MRUYH NSWEI OTBFK PADGL",b[]="|||||";i=strchr(r,getchar())-r;b[i%5]=47;b[i/5]=92;puts(b);}

टूट - फूट:

x;                                      // Implicit int declaration
main(i,v)char**v;{                      // K&R function declaration to save a byte
    for(i=strcspn("<...>",v[1]);        // Find index of input in lookup table
        x<5;++x)                        // Loop 0 to 4
        putchar(x^i%5?x^i/5?124:92:47); //  Print /, \ or | depending on value of i
}

वैकल्पिक ब्रेकडाउन:

main(i){
    char*r="<...>",                     // Store lookup table
    b[]="|||||";                        // Malleable base string for return
    i=strchr(r,getchar())-r;            // Find input in lookup table
    b[i%5]=47;                          // Set correct char in output to /
    b[i/5]=92;                          // Set correct char in output to \
    puts(b);                            // Print result
}

बोनस: विकिपीडिया पेज से 0-9 एक्सटेंशन:

x;main(i,v)char**v;{for(i=strcspn(" MRUY6H NSW7EI OT8BFK P9ADGL 012345",v[1]);x<5;++x)putchar(x^i%6?x^i/6?124:92:47);}

बोनस बोनस: एन्कोडिंग और डिकोडिंग दोनों संदेशों के लिए एक पूर्ण (यदि गन्दा है) कार्यक्रम:

#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdbool.h>

static const char *REF = " MRUY6H NSW7EI OT8BFK P9ADGL 012345 ";

char sub(char c) {
    c = toupper(c);
    if(c == 'C') { c = 'K'; }
    if(c == 'J') { c = 'G'; }
    if(c == 'Q') { c = 'K'; }
    if(c == 'V') { c = 'W'; }
    if(c == 'X') { c = 'S'; }
    if(c == 'Z') { c = 'S'; }
    return c;
}

void print_encoded(char c) {
    char b[] = "|||||";
    const char *p = strchr(REF, sub(c));
    if(!p) { return; }
    int i = p - REF;
    if(i) {
        if(i%6 < 5) { b[i%6] = '/'; }
        if(i/6 < 5) { b[i/6] = '\\';}
    }
    puts(b);
}

char decode(const char *m) {
    int pf = 5;
    int pb = 5;
    for(int x=0;x<5;++x) {
        if(m[x] == '/') {
            pf=x;
        } else if(m[x] == '\\') {
            pb=x;
        } else if(m[x] == '\0') {
            return '!';
        }
    }
    return REF[pb*6+pf];
}

int main(int c, const char **v) {
    int inArg;
    bool isDecode;
    if(c > 1 && (strcmp(v[1], "-h") == 0 || strcmp(v[1], "--help") == 0)) {
        printf("Usage:\n  %s [-d] [<input>]\n\n", v[0]);
        printf("Converts input to/from Cooke and Wheatstone 5-needle encoding.\n\n");
        printf("If no input arguments are given, takes input from stdin.\n\n");
        printf("Parameters:\n");
        printf("  -h --help   Displays help.\n");
        printf("  -d --decode Switches to decode mode.\n");
        printf("\n");
        return 0;
    } else if(c > 1 && (strcmp(v[1], "-d") == 0 || strcmp(v[1], "--decode") == 0)) {
        inArg = (c > 2 ? 2 : 0);
        isDecode = true;
    } else if(c > 1) {
        inArg = 1;
        isDecode = false;
    } else {
        inArg = 0;
        isDecode = false;
    }
    if(isDecode) {
        if(inArg == 0) {
            char ln[6];
            while(scanf("%5s", ln) == 1) {
                putchar(decode(ln));
            }
        } else {
            for(int p = inArg; p < c; ++p) {
                for(const char *q = v[p], *e = strchr(v[p], '\0'); q < e; q += 5) {
                    while(*q == ' ') { ++q; }
                    putchar(decode(q));
                }
            }
        }
        putchar('\n');
    } else {
        if(inArg == 0) {
            int c;
            while((c = getchar()) != EOF) {
                print_encoded(c);
            }
        } else {
            for(const char *p = v[inArg]; *p; ++p) {
                print_encoded(*p);
            }
        }
    }
    return 0;
}

5

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

r"HEBAMRUYIFDNSWKGOTLP"5e!{_$"/\|"er}%_&er

इसका परीक्षण यहां करें

हालाँकि आउटपुट के लिए बहुत सारी संरचनाएँ हैं, लेकिन मुझे पूरी तरह से यकीन नहीं है कि मैं अभी तक परिणामों को कुशलतापूर्वक (बाइट्स के संदर्भ में) गणना कर सकता हूँ। तो यह अभी भी एक खोज तालिका है, लेकिन मैं सूची के क्रमपरिवर्तन के माध्यम से संभावित सुई विन्यास की सूची तैयार कर रहा हूं [0 1 2 3 4]


3

MATL , 50 बाइट्स

'!#$kYAqof^EZC}40iA*9n4JK?45/J~v'6Y2'\|/'Za5eioZ)!

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

संक्षिप्त व्याख्या

कोड '!#$...J~v'एक स्ट्रिंग युक्त में दिखाया स्ट्रिंग ( ) को विघटित करता है \, |और /; इसे एक सरणी में बदल देता है जहां प्रत्येक स्तंभ एक पत्र से मेल खाता है; और इनपुट चरित्र के साथ उस सरणी को अनुक्रमित करता है।

लंबी व्याख्या

कंप्रेस किया गया स्ट्रिंग बेस -3 से बेस -95 एनकोडिंग का उपयोग करके (ऑफलाइन) प्राप्त किया गया है। चुनौती के डेटा को एक लंबी स्ट्रिंग में व्यवस्थित किया गया है \, |और /, जहां प्रत्येक 5अक्षर का समूह एक पत्र से मेल खाता है। इस स्ट्रिंग की व्याख्या कुछ बड़ी संख्या के आधार -3 प्रतिनिधित्व के रूप में की जाती है, जिसे अंकों के रूप में सभी मुद्रण योग्य ASCII वर्णों का उपयोग करके आधार -95 में बदल दिया जाता है। परिणाम कोड में दिखाई देने वाली संकुचित स्ट्रिंग है ( '!#$...J~v')।

कार्यक्रम इस स्ट्रिंग, कि है, वर्णमाला के साथ आधार -3 के आधार -95 से परिवर्तित decompressing शुरू होता है \, |, /। विघटित स्ट्रिंग को 5-पंक्ति 2 डी चार सरणी में बदल दिया जाता है, जिसमें प्रत्येक स्तंभ एक पत्र का प्रतिनिधित्व करता है। इस सरणी को कॉल करते हैं Λ। इस सरणी को इनपुट पत्र के ASCII कोड बिंदु का उपयोग करके अनुक्रमित किया जाएगा।

सरणी Λमें दो चालें शामिल हैं:

  1. यह के बीच लापता पाँच अक्षरों के लिए डमी मूल्यों से भर दिया गया है Aऔर Y;
  2. यह L(नहीं A) से शुरू होता है और फिर परिपत्र रूप से आगे बढ़ता है।

इन दो तरकीबों के कारण इस प्रकार हैं:

  1. लेटर Aमें कोड प्वाइंट होता है 65। अंतिम पत्र जिसे संभाला जाना चाहिए Y, कोड बिंदु के साथ है 89। इसलिए हमें 25मूल्यों की एक श्रृंखला को संभालने की आवश्यकता है , भले ही कुछ मध्यवर्ती (जैसे कि पत्र C) मौजूद न हों। अनुक्रमण को सुविधाजनक बनाने के लिए, बीच के पांच लापता अक्षर Aऔर Yएक डमी प्रतिनिधित्व के साथ भरे गए हैं, इसलिए उनके पास एक कॉलम है Λ। इस प्रकार, Λआकार 5 × 25 है।

  2. मॉड्यूलर इंडेक्सिंग का उपयोग किया जाता है। तो अक्षर A, या संख्या 65, वही है 65 mod 25, जो है 15। इसलिए Aकॉलम में होने की जरूरत है 15की Λ, Bकॉलम में 16, ..., और Yकॉलम में 14

टिप्पणी कोड

'!#$kYAqof^EZC}40iA*9n4JK?45/J~v'     % Compressed string (in base-95)
6Y2                                   % Predefined literal 'AB...Z': source alphabet
                                      % for decompression
'\|/'                                 % Target alphabet for decompression
Za                                    % Change of base representation (decompress)
5e                                    % Reshape into 5-row array `Λ`
i                                     % Input letter
o                                     % Convert to number (ASCII code point)
Z)                                    % Use as column index into `Λ`
!                                     % Transpose into a row. Implicitly display

3

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

lambda x:r'/|||\/|||/\|||/|\||/||\|/||'['APONM LKIHY GFEWU DBTSR'.find(x):][:5]

कोई एल्गोरिथ्म नहीं, बस एक लुकअप टेबल।

@LeakyNun की बदौलत 20 बाइट्स बचाए!

@TheBikingViking के लिए एक बाइट धन्यवाद सहेजा गया!

@Keeta की बदौलत एक भारी 72 बाइट बचा लिया!


आप -1 बाइट के findबदले उपयोग कर सकते हैं index
TheBikingViking

2
यदि आप स्लैश के ओवरलैप का फायदा उठाते हैं, तो आप लैम्बडा x: r '/ / / \ / \ / / / / \ / / / / / / \ / \ / / \ / \ जैसी कुछ चीज़ों को 72 अक्षरों से कम कर सकते हैं। || '' 'APONM LKIHY GFEWU DBTSR'.find (x):]: [: 5]
कीटा - पुनः स्थापित मोनिका


1

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

c=>(n=`ABEHMDFINRGKOSULPTWY`.search(c),s=[...`|||||`],s[4-n%5]=`\\`,s[n>>2]=`/`,s.join``)

संपादित करें: 3 बाइट्स को एक लुकअप टेबल पर स्विच करके सहेजा गया है जिसमें पैडिंग की आवश्यकता नहीं है। स्ट्रिंग को संपादित करने के बजाय सरणी तत्वों को सेट करके 5 बाइट्स सहेजे गए।

स्पष्टीकरण: तालिका ABEHMDFINRGKOSULPTWYको व्यवस्थित किया जाता है ताकि यदि आप इसे 4 आसन्न अक्षरों के 5 समूहों में विभाजित करते हैं, तो समूह में प्रत्येक अक्षर /आरेख में एक ही तिरछा पर होता है, जबकि यदि आप इसे सूचकांक modulo 5 में से 5 समूहों में विभाजित करते हैं: समूह में पत्र \आरेख में एक ही तिरछा पर है। ये बाद वाले समूह रिवर्स ऑर्डर में हैं, लेकिन इसे आसानी से 4 से घटाकर नियंत्रित किया जाता है (तालिका को व्यवस्थित करना ताकि पूर्व समूह रिवर्स ऑर्डर लागत को ठीक करने के लिए अधिक हो।)


1

VBA, 106 बाइट्स

Function v(s):v="|||||":p=InStr(1,v &"MRUYH NSWEI OTBFK PADGL",s):Mid(v, p\5)="\":Mid(v, (p Mod 5)+1)="/"

फाइनल बाइट वह है enterजो ऑटो जेनरेट करता है End Functionइस योजना को स्वीकार करने के साथ @ तैयार किया गया

स्प्रेडशीट में या VBA तत्काल विंडो जैसे उदाहरण में शामिल करें ?v("K")


0

गणितज्ञ, 129 बाइट्स

""<>(IntegerDigits[IntegerDigits[36^^3ucgb2abu46m2rewohw225q4lc6hczypueyb3,190][[LetterNumber@#]],3,5]/.{0->"|",1->"/",2->"\\"})&

अनाम फ़ंक्शन। एक स्ट्रिंग को इनपुट के रूप में लेता है और एक स्ट्रिंग को आउटपुट के रूप में अपने कोड का प्रतिनिधित्व करता है। अपेक्षाकृत सरल एन्कोडिंग योजना का उपयोग करता है।


0

पायथ, 27 बाइट्स

@{.p"/|\||"x."AW
Ú/Ç\x94E\x18µð££

इसी बाइट के साथ \x94, पलायन को बदलें \x18

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

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

@                                      index into this list:
  .p"/|\||"                              permutations of /|\||
 {                                       deduplicate
                                       at index:
            ."AW\nÚ/Ç\x94E\x18µð££"      compressed string: EBAHIFDNSWKGOTLPMRU
           x                       Q     index in that of input (or -1 for Y)

पायथ, 32 बाइट्स

किसी भी हार्ड-कोडित लुकअप टेबल का उपयोग किए बिना।

@o-xN\/xN\\{.p"/\|||"x-rG2"CJQVX

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

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

@                                    index into this list:
            .p"/\|||"                  all permutations of /\|||
           {                           deduplicate
 o                                     sort by the following key for N in the list:
   xN\/                                  index of / in N
  -    xN\\                              … minus index of \ in N
                                     at index:
                       rG2             capitalized alphabet
                      -   "CJQVX"      minus CJQVX
                     x           Q     index in that of input

0

अजगर 2, 115 111 बाइट्स

यह एक सरल कार्यान्वयन है, लेकिन यह कुछ गोल्फ का उपयोग कर सकता है। सुझाव का स्वागत करते हैं।

def f(c):s=["|"]*5;a=0xdb52384ebd9f46caa72899c838d50/25**(ord(c)-65)%25;s[a/5]="/";s[a%5]="\\";return''.join(s)

Ungolfed:

def f(c):
    s = ["|"] * 5
    d = ord(c) - 65
    # 0xdb52384ebd9f46caa72899c838d50 is our lookup number
    # 0040004100304231200043322110342300120124130214000304
    # in hexadecimal
    a = 0xdb52384ebd9f46caa72899c838d50 / 25**d % 25
    s[a/5] = "/"
    s[a%5] = "\\"
    return ''.join(s)

0

सी, 78 बाइट्स

i;f(x){for(i=5;i--;)putchar("|/\\|"["^\\ NXLFPH DBow{} gsyc q a"[x-65]>>i&3]);}

दिखाया संस्करण सभी मुद्रण योग्य ASCII, 79 बाइट्स है। दूसरा \\किसी भी एकल बाइट द्वारा प्रतिस्थापित किया जा सकता है जिसमें \चरित्र 0x5C: 0x1C (यदि आपका संकलक इसे अनुमति देता है), 0x9C या 0xDC के समान 6 बिट्स हैं ।

इनपुट चरित्र जादू स्ट्रिंग जिसके लिए मान में देखा जाता है Aके लिए Y(असमर्थित वर्ण के लिए रिक्त स्थान सहित CJQVXलुकअप तालिका से चरित्र 2-बिट कोड जहां ओवरलैपिंग पाँच के रूप में व्याख्या की है।):

01 = /   10 = \    00 or 11 = |

परीक्षण कार्यक्रम में टिप्पणी कोड

/*
magic string codes: bytes are 01XXXXXX
A     /|||\ 011110 ^
B     /||\| 011100 \\
D     |/||\ 001110 N 
E     /|\|| 011000 X
F     |/|\| 001100 L
G     ||/|\ 000110 F
H     /\||| 010000 P
I     |/\|| 001000 H
K     ||/\| 000100 D
L     |||/\ 000010 B
M     \/||| 101111 o
N     |\/|| 110111 w
O     ||\/| 111011 {
P     |||\/ 111101 }
R     \|/|| 100111 g
S     |\|/| 110011 s
T     ||\|/ 111001 y
U     \||/| 100011 c
W     |\||/ 110001 q
Y     \|||/ 100001 a

                                     ABBCDEFGHIJKLMNOPQRSTUVWXY*/
i;f(x){for(i=5;i--;)putchar("|/\\|"["^\\ NXLFPH DBow{} gsyc q a"[x-65]>>i&3]);}

j;
main(){
  j=getchar();
  f(j);
} 

0

रूबी, 159 बाइट्स

v=[1,2,3,4,7,8,9,13,14,19];w=v+v.map{|e|25+e};a="HEBAIFDKGLMRUYNSWOTP";b="\\/"
x=w[a.index($*[0][0])];g="|"*5;y=(x>25)?0:1;g[(x/5)%5]=b[y];g[x%5]=b[1-y];puts g

स्पष्टीकरण:

विक्षेपित सुइयों की स्थिति को 0..4 पर मैप किया जाता है, और आधार -5 नंबर (2 अंक) के रूप में सोचा जाता है। AL के लिए, संख्या "जैसा है" है; MZ के लिए, संख्या में 25 जोड़ें। नक्शा चर aसे है w

पत्र के अनुरूप संख्या को देखते हुए, इसके आधार -5 प्रतिनिधित्व का उपयोग करें: पहली सुई के लिए 5s अंक, दूसरी सुई के लिए 1s अंक और सुइयों के निर्देशों के लिए 25s अंक।

एक वर्ण के बजाय एक पूरे स्ट्रिंग को एनकोड करने का कार्यक्रम, बस थोड़ा लंबा है: 172 बाइट्स।

v=[1,2,3,4,7,8,9,13,14,19];w=v+v.map{|e|25+e};a="HEBAIFDKGLMRUYNSWOTP";b="\\/"
$*[0].each_char{|c|x=w[a.index(c)];g="|"*5;y=(x>25)?0:1;g[(x/5)%5]=b[y];g[x%5]=b[1-y];puts g}
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.