Cooke und Wheatstone Telegraph, Fünfnadel

20

Definition

Laut Wikipedia :

Der Cooke and Wheatstone-Telegraph war ein frühes elektrisches Telegraphensystem aus den 1830er Jahren, das vom englischen Erfinder William Fothergill Cooke und dem englischen Wissenschaftler Charles Wheatstone erfunden wurde. Es war das erste Telegraphensystem, das in den kommerziellen Dienst gestellt wurde. Der Empfänger bestand aus einer Anzahl von Nadeln, die durch elektromagnetische Spulen bewegt werden konnten, um auf Buchstaben auf einer Tafel zu zeigen. Diese Funktion fand großen Anklang bei frühen Benutzern, die keine Codes lernen wollten, und bei Arbeitgebern, die nicht in die Schulung ihrer Mitarbeiter investieren wollten.

Das funktioniert so:

Schema von Cooke und Wheatstone Telegraph, fünfnadelig

In der Mitte befinden sich fünf Nadeln, die im Uhrzeigersinn (wie bei der mittleren Nadel) oder gegen den Uhrzeigersinn (wie bei der letzten Nadel) ausgelenkt werden können.

Im obigen Bild zeigen die beiden abgelenkten Nadeln auf den Brief G, was bedeutet, dass der gesendete / empfangene Brief der Brief ist G.

Beachten Sie, dass die Buchstaben C, J, Q, V, X, Zfehlen und müssen somit mit anderen Buchstaben ersetzt werden.

Aufgabe

Sie erhalten ein Zeichen ABDEFGHIKLMNOPRSTUWYals Eingabe und geben die entsprechende Konfiguration der fünf Nadeln aus, wobei nicht |abgelenkt als /, im Uhrzeigersinn als und gegen den Uhrzeigersinn als abgelenkt wird \.

Testfälle

Dies umfasst alle möglichen Eingaben

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     \|||/

Regeln / Anforderungen

  • Jede Einreichung sollte entweder ein vollständiges Programm oder eine Funktion sein. Wenn es sich um eine Funktion handelt, muss sie ausgeführt werden können, indem nur der Funktionsaufruf am Ende des Programms hinzugefügt wird. Alles andere (z. B. Überschriften in C) muss enthalten sein.
  • Wenn es möglich ist, geben Sie einen Link zu einer Site an, auf der Ihr Programm getestet werden kann.
  • Ihr Programm darf nichts schreiben STDERR.
  • Standardlücken sind verboten.
  • Ihr Programm kann in jedem Fall ausgeben, es muss jedoch gedruckt werden (kein Array oder ähnliches).

Wertung

Programme werden nach Bytes, standardmäßig in UTF-8 oder einem anderen Zeichensatz Ihrer Wahl bewertet.

Eventuallygewinnt die Antwort mit den wenigsten Bytes.

Einreichungen

Um sicherzustellen, dass Ihre Antwort angezeigt wird, beginnen Sie Ihre Antwort mit einer Überschrift. Verwenden Sie dazu die folgende Markdown-Vorlage:

# Language Name, N bytes

Wo Nist die Größe Ihres Beitrags? Wenn Sie Ihren Score zu verbessern, Sie können alte Rechnungen in der Überschrift halten, indem man sich durch das Anschlagen. Zum Beispiel:

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

Wenn Sie mehrere Zahlen in Ihre Kopfzeile aufnehmen möchten (z. B. weil Ihre Punktzahl die Summe von zwei Dateien ist oder wenn Sie die Strafen für Interpreter-Flags separat auflisten möchten), stellen Sie sicher, dass die tatsächliche Punktzahl die letzte Zahl in der Kopfzeile ist:

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

Sie können den Namen der Sprache auch als Link festlegen, der dann im Leaderboard-Snippet angezeigt wird:

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

Bestenliste

Hier ist ein Stack-Snippet, um sowohl eine reguläre Rangliste als auch eine Übersicht der Gewinner nach Sprache zu erstellen.

Code-Snippet anzeigen

code-golf ascii-art kolmogorov-complexity Undichte Nonne
quelle

Antworten:

6

C, 124 107 98 Bytes

Als eine Funktion:

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]);}

Dies funktioniert, indem Sie das Raster um 45 Grad drehen und die Zeile / Spalte des resultierenden Blocks nachschlagen.

Als vollständige ausführbare Datei (107 Byte):

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);}

Eine alternative ausführbare Datei: (Gleiches bytecount, aber Eingabe von stdin und Zeilenvorschub nach Ausgabe)

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

Nervenzusammenbruch:

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
}

Alternative Aufteilung:

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
}

Bonus: 0-9 Erweiterung von der Wikipedia-Seite:

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);}

Bonus Bonus: Ein komplettes (wenn auch unordentliches) Programm zum Kodieren und Dekodieren von Nachrichten:

#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;
}
Dave
quelle
5

CJam, 42 Bytes

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

Teste es hier

Obwohl die Ausgaben sehr strukturiert sind, bin ich mir nicht ganz sicher, ob ich die Ergebnisse effizient (in Byte) berechnen kann. Das ist also immer noch eine Nachschlagetabelle, aber ich erstelle die Liste der möglichen Nadelkonfigurationen über Permutationen der Liste [0 1 2 3 4].

Martin Ender
quelle
3

MATL , 50 Bytes

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

Probieren Sie es online!

Kurze Erklärung

Der Code dekomprimiert die Zeichenkette dargestellt ( '!#$...J~v') in eine Zeichenfolge enthält \, |und /; formt es in ein Array um, in dem jede Spalte einem Buchstaben entspricht; und indiziert dieses Array mit dem Eingabezeichen.

Lange Erklärung

Die komprimierte Zeichenfolge wurde (offline) mit der Base-3-zu-Base-95-Codierung abgerufen. Die Daten aus der Herausforderung wurden in eine lange Reihe von angeordneten \, |und /, wobei jede Gruppe von 5Zeichen entsprechen einen Buchstaben. Diese Zeichenfolge wird als Basis-3-Darstellung einer großen Zahl interpretiert, die unter Verwendung aller druckbaren ASCII-Zeichen als Ziffern in Basis-95 konvertiert wird. Das Ergebnis ist die komprimierte Zeichenfolge, die im Code ( '!#$...J~v') angezeigt wird .

Das Programm startet diese Zeichenfolge Dekomprimieren, das heißt, die Umwandlung von der Basis-95 zur Basis-3 mit dem Alphabet \, |, /. Die dekomprimierte Zeichenfolge wird in ein 5-zeiliges 2D-Zeichen-Array umgewandelt, in dem jede Spalte einen Buchstaben darstellt. Nennen wir dieses Array Λ. Dieses Array wird mit dem ASCII-Code des eingegebenen Buchstabens indiziert.

Das Array Λenthält zwei Tricks:

  1. Es wurde mit Dummy-Werten für die fünf Buchstaben gefüllt, die zwischen Aund fehlen Y.
  2. Es beginnt mit L(nicht A) und geht dann kreisförmig weiter.

Die Gründe für diese beiden Tricks sind folgende:

  1. Brief Ahat Code Punkt 65. Der letzte Buchstabe, der behandelt werden muss, ist Ymit Code-Punkt 89. Wir müssen also mit einer Reihe von 25Werten umgehen , auch wenn einige Zwischenwerte (wie Buchstaben C) nicht existieren. Um die Indizierung zu erleichtern, wurden die fünf fehlenden Buchstaben zwischen Aund Ymit einer Dummy-Darstellung gefüllt, sodass sie eine Spalte enthalten Λ. Somit Λhat Größe 5 × 25.

  2. Modulare Indizierung wird verwendet. So Brief Aoder Zahl 65, ist das gleiche wie 65 mod 25, das heißt 15. Daher Amuss in der Spalte sein 15von Λ, Bin der Spalte 16, ..., und Yin der Spalte 14.

Kommentierter Code

'!#$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
Luis Mendo
quelle
3

Python 2, 172 152 151 79 Bytes

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

Kein Algorithmus, nur eine Nachschlagetabelle.

20 Bytes gespart dank @LeakyNun!

Dank @TheBikingViking ein Byte gespart!

Dank @Keeta konnten satte 72 Bytes eingespart werden!

Kupfer
quelle
Sie können findanstelle von index-1 Byte verwenden.
TheBikingViking
2
Wenn Sie die Überlappung der Schrägstriche ausnutzen, können Sie sie um 72 Zeichen auf so etwas wie Lambda x reduzieren: r '/ ||| \ / ||| / \ ||| / \ || / || \ | / || '[' APONM LKIHY GFEWU DBTSR'.find (x):] [: 5]
Keeta - Setzen Sie Monica
1

JavaScript (ES6), 97-89 Byte

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

Bearbeiten: Speichert 3 Bytes durch Wechseln zu einer Nachschlagetabelle, für die kein Auffüllen erforderlich ist. 5 Bytes gespart, indem Array-Elemente festgelegt wurden, anstatt zu versuchen, eine Zeichenfolge zu bearbeiten.

Erläuterung: Die Tabelle ABEHMDFINRGKOSULPTWYist so organisiert, dass, wenn Sie sie in 5 Gruppen mit jeweils 4 benachbarten Buchstaben aufteilen, jeder Buchstabe in der Gruppe /im Diagramm dieselbe Neigung aufweist. Wenn Sie sie in 5 Gruppen aufteilen, nehmen Sie den Index modulo 5 Der Buchstabe in der Gruppe befindet sich \im Diagramm auf der gleichen Neigung. Diese letzteren Gruppen sind in umgekehrter Reihenfolge, aber das ist einfach durch Subtrahieren von 4 zu handhaben.

Neil
quelle
1

VBA, 106 Bytes

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

Das letzte Byte wird enterautomatisch generiert End Function. Mit Danksagungen zum Schema @Dave erfunden .

In der Tabelle oder im VBA-Direktfenster aufrufen, z. B. mit ?v("K")

Joffan
quelle
0

Mathematica, 129 Bytes

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

Anonyme Funktion. Nimmt eine Zeichenfolge als Eingabe und gibt eine Zeichenfolge zurück, die den Code als Ausgabe darstellt. Verwendet ein relativ einfaches Codierungsschema.

LegionMammal978
quelle
0

Pyth, 27 Bytes

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

Ersetzt die entweicht \x94, \x18mit dem entsprechenden Bytes.

Probieren Sie es online aus

Wie es funktioniert

@                                      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)

Pyth, 32 Bytes

Ohne hartcodierte Nachschlagetabellen zu verwenden.

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

Probieren Sie es online aus

Wie es funktioniert

@                                    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
Anders Kaseorg
quelle
0

Python 2, 115 111 Bytes

Dies ist eine einfache Implementierung, die jedoch etwas Golfspiel verträgt. Vorschläge sind willkommen.

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)
Sherlock9
quelle
0

C 78 Bytes

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

Die angezeigte Version ist allesamt druckbares ASCII, 79 Bytes. Die Sekunde \\kann durch ein einzelnes Byte ersetzt werden, das die gleichen letzten 6 Bits wie das \Zeichen 0x5C: 0x1C (sofern Ihr Compiler dies zulässt), 0x9C oder 0xDC enthält.

Das eingegebene Zeichen wird in der magischen Zeichenfolge nachgeschlagen, die Werte für Abis enthält Y(einschließlich Leerzeichen für die nicht unterstützten Zeichen CJQVX). Das Zeichen aus der Nachschlagetabelle wird als fünf überlappende 2-Bit-Codes interpretiert, wobei:

01 = /   10 = \    00 or 11 = |

Kommentierter Code im Testprogramm

/*
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);
}
Level River St
quelle
0

Ruby, 159 Bytes

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

Erläuterung:

Die Positionen der abgelenkten Nadeln werden auf 0..4 abgebildet und als Zahl zur Basis 5 (2 Stellen) gedacht. Für AL sind die Zahlen "wie sie sind"; Für MZ addieren Sie 25 zur Zahl. Die Karte ist von Variablen abis w.

Verwenden Sie für die Zahl, die dem Buchstaben entspricht, die Basis-5-Darstellung: die 5-stellige Zahl für die erste Nadel, die 1-stellige Zahl für die zweite Nadel und die 25-stellige Zahl für die Nadelrichtungen.

Ein Programm zum Codieren einer gesamten Zeichenfolge anstelle eines Zeichens ist nur ein bisschen länger: 172 Byte.

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}
jose_castro_arnaud
quelle