Telegrafo di Cooke e Wheatstone, a cinque aghi


20

Definizione

Secondo Wikipedia :

Il telegrafo di Cooke e Wheatstone era un primo sistema di telegrafia elettrico risalente al 1830, inventato dall'inventore inglese William Fothergill Cooke e dallo scienziato inglese Charles Wheatstone. Fu il primo sistema telegrafico ad essere messo in servizio commerciale. Il ricevitore consisteva in un numero di aghi che potevano essere mossi da bobine elettromagnetiche per indicare le lettere su una lavagna. Questa funzionalità è piaciuta ai primi utenti che non erano disposti a imparare i codici e ai datori di lavoro che non volevano investire nella formazione del personale.

Funziona così:

Schema del telegrafo di Cooke e Wheatstone, a cinque aghi

Nel mezzo ci sono cinque aghi, che possono essere deviati in senso orario (come nel caso dell'ago centrale) o in senso antiorario (come nel caso dell'ultimo ago).

Nella foto sopra, i due aghi deviati indicano la lettera G, il che significa che la lettera che viene trasmessa / ricevuta è la lettera G.

Si noti che le lettere C, J, Q, V, X, Zsono mancanti e pertanto devono essere sostituite con altre lettere.

Compito

Riceverai un carattere ABDEFGHIKLMNOPRSTUWYcome input e otterrai la configurazione corrispondente dei cinque aghi, con undeflected come |, deviato in senso orario come /e deviato in senso antiorario come \.

Casi test

Questo copre tutti gli input possibili

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

Regole / Requisiti

  • Ogni invio dovrebbe essere un programma o una funzione completi. Se è una funzione, deve essere eseguibile solo aggiungendo la chiamata di funzione nella parte inferiore del programma. Qualsiasi altra cosa (ad es. Intestazioni in C) deve essere inclusa.
  • Se possibile, fornire un collegamento a un sito in cui è possibile testare il programma.
  • Il tuo programma non deve scrivere nulla su STDERR.
  • Sono vietate le scappatoie standard .
  • Il tuo programma può essere emesso in ogni caso, ma deve essere stampato (non un array o simile).

punteggio

I programmi vengono classificati in base ai byte, in UTF-8 per impostazione predefinita o in un set di caratteri diverso a scelta.

Eventually, vincerà la risposta con il minor numero di byte.

Inseriti

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, utilizzando il seguente modello Markdown:

# Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

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

Se si desidera includere più numeri nell'intestazione (ad es. Perché il punteggio è la somma di due file o si desidera elencare separatamente le penalità del flag dell'interprete), assicurarsi che il punteggio effettivo sia l' ultimo numero nell'intestazione:

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

Puoi anche rendere il nome della lingua un collegamento che verrà quindi visualizzato nello snippet della classifica:

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

Classifica

Ecco uno snippet di stack per generare sia una classifica regolare che una panoramica dei vincitori per lingua.

Risposte:


6

C, 124 107 98 byte

Come una funzione:

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

Funziona usando la rotazione della griglia di 45 gradi e guardando la riga / colonna dal blocco risultante.


Come eseguibile completo (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);}

Un eseguibile completo alternativo: (stesso byte ma prende input da stdin e include newline dopo output)

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

Abbattersi:

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
}

Ripartizione alternativa:

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: estensione 0-9 dalla pagina di Wikipedia:

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: un programma completo (se disordinato) per i messaggi di codifica e decodifica:

#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

CJam, 42 byte

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

Provalo qui

Sebbene ci sia molta struttura negli output, non sono del tutto sicuro di poter calcolare i risultati in modo efficiente (in termini di byte). Quindi questa è ancora una tabella di ricerca, ma sto generando l'elenco delle possibili configurazioni dell'ago tramite permutazioni dell'elenco [0 1 2 3 4].


3

MATL , 50 byte

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

Provalo online!

Breve spiegazione

Il codice decomprime la stringa mostrata ( '!#$...J~v') in una stringa contenente \, |e /; lo rimodella in una matrice in cui ogni colonna corrisponde a una lettera; e indicizza quell'array con il carattere di input.

Lunga spiegazione

La stringa compressa è stata ottenuta (offline) usando la codifica da base 3 a base 95. I dati della sfida sono stati organizzati in una lunga serie di \, |e /, in cui ciascun gruppo di 5caratteri corrisponde a una lettera. Questa stringa viene interpretata come la rappresentazione di base 3 di alcuni numeri grandi, che viene convertita in base-95, usando tutti i caratteri ASCII stampabili come cifre. Il risultato è la stringa compressa che appare nel codice ( '!#$...J~v').

Il programma si avvia decomprimere questa stringa, che è, la conversione da base-95 a base-3 con l'alfabeto \, |, /. La stringa decompressa viene rimodellata in un array di caratteri 2D a 5 righe, in cui ogni colonna rappresenta una lettera. Chiamiamo questo array Λ. Questo array verrà indicizzato usando il punto di codice ASCII della lettera di input.

L'array Λinclude due trucchi:

  1. È stato riempito con valori fittizi per le cinque lettere mancanti tra Ae Y;
  2. Inizia con L(non A) e poi procede in modo circolare.

Le ragioni di questi due trucchi sono le seguenti:

  1. La lettera Aha un punto di codice 65. L'ultima lettera che deve essere gestita è Y, con punto di codice 89. Quindi dobbiamo gestire un intervallo di 25valori, anche se alcuni di quelli intermedi (come la lettera C) non esistono. Per facilitare l'indicizzazione, le cinque lettere mancanti tra Ae Ysono state riempite con una rappresentazione fittizia, quindi hanno una colonna dentro Λ. Pertanto, Λha dimensioni 5 × 25.

  2. Viene utilizzato l'indicizzazione modulare. Quindi la lettera A, o il numero 65, è lo stesso di 65 mod 25, cioè 15. Pertanto Adeve essere nella colonna 15di Λ, Bnella colonna 16, ... e Ynella colonna 14.

Codice commentato

'!#$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

Python 2, 172 152 151 79 byte

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

Nessun algoritmo, solo una tabella di ricerca.

Risparmiato 20 byte grazie a @LeakyNun!

Salvataggio di un byte grazie a @TheBikingViking!

Salvato un enorme 72 byte grazie alla @Keeta!


È possibile utilizzare findanziché indexper -1 byte.
TheBikingViking

2
Se approfitti della sovrapposizione delle barre, puoi ridurre di 72 caratteri a qualcosa come lambda x: r '/ ||| \ / ||| / \ ||| / | \ || / || \ | / || '[' APONM LKIHY GFEWU DBTSR'.find (x):] [: 5]
Keeta - ripristina Monica il


1

JavaScript (ES6), 97 89 byte

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

Modifica: salvato 3 byte passando a una tabella di ricerca che non necessita di riempimento. 5 byte salvati impostando gli elementi dell'array invece di provare a modificare una stringa.

Spiegazione: La tabella ABEHMDFINRGKOSULPTWYè organizzata in modo tale che se la si divide in 5 gruppi di 4 lettere adiacenti, ogni lettera nel gruppo si trova sulla stessa /inclinazione nel diagramma, mentre se la si divide in 5 gruppi prendendo l'indice modulo 5, allora ciascuno la lettera nel gruppo si trova sulla stessa \inclinazione nel diagramma. Questi ultimi gruppi sono in ordine inverso, ma è facilmente gestibile sottraendo da 4. (Organizzare la tabella in modo che i precedenti gruppi fossero in ordine inverso sono più costosi da correggere).


1

VBA, 106 byte

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

Il byte finale è quello enterche si genera automaticamente End Function. Con riconoscimenti allo schema ideato da @Dave .

Richiamare nel foglio di calcolo o nella finestra immediata di VBA, ad es. Con ?v("K")


0

Mathematica, 129 byte

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

Funzione anonima. Prende una stringa come input e restituisce una stringa che rappresenta il suo codice come output. Utilizza uno schema di codifica relativamente semplice.


0

Pyth, 27 byte

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

Sostituire le fughe \x94, \x18con i byte corrispondenti.

Provalo online

Come funziona

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

Senza utilizzare alcuna tabella di ricerca codificata.

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

Provalo online

Come funziona

@                                    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

Python 2, 115 111 byte

Questa è una semplice implementazione, ma potrebbe usare un po 'di golf. Suggerimenti benvenuti.

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

C, 78 byte

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

la versione mostrata è tutta ASCII stampabile, 79 byte. Il secondo \\può essere sostituito da qualsiasi singolo byte che ha gli stessi ultimi 6 bit del \carattere 0x5C: 0x1C (se il compilatore lo consente), 0x9C o 0xDC.

Il carattere di input viene cercato nella stringa magica che contiene valori per Aa Y(spazi compresi per i caratteri non supportati CJQVXil carattere dalla tabella di ricerca viene interpretato come cinque sovrapposizione codici a 2 bit dove.):

01 = /   10 = \    00 or 11 = |

Codice commentato nel programma di test

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

Rubino, 159 byte

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

Spiegazione:

Le posizioni degli aghi deviati sono mappate su 0..4 e considerate come un numero base-5 (2 cifre). Per AL, i numeri sono "così come sono"; per MZ, aggiungi 25 al numero. La mappa è dalle variabili aa w.

Dato il numero corrispondente alla lettera, usa la sua rappresentazione base-5: la cifra 5s per il primo ago, la cifra 1s per il secondo ago e la cifra 25s per le direzioni degli aghi.

Un programma per codificare un'intera stringa, anziché un carattere, è solo un po 'più lungo: 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}
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.