Telégrafo Cooke y Wheatstone, cinco agujas

20

Definición

De acuerdo con Wikipedia :

El telégrafo Cooke y Wheatstone fue uno de los primeros sistemas de telégrafo eléctrico que data de la década de 1830 inventado por el inventor inglés William Fothergill Cooke y el científico inglés Charles Wheatstone. Fue el primer sistema telegráfico puesto en servicio comercial. El receptor constaba de una serie de agujas que podían ser movidas por bobinas electromagnéticas para señalar letras en un tablero. Esta característica fue del agrado de los primeros usuarios que no estaban dispuestos a aprender códigos, y los empleadores que no querían invertir en la capacitación del personal.

Funciona así:

Esquema de telégrafo Cooke y Wheatstone, cinco agujas

En el medio hay cinco agujas, que pueden desviarse en sentido horario (como es el caso de la aguja central) o en sentido antihorario (como es el caso de la última aguja).

En la imagen de arriba, las dos agujas desviadas apuntan a la letra G, lo que significa que la letra que se transmite / recibe es la letra G.

Tenga en cuenta que las letras C, J, Q, V, X, Zse han perdido y por lo tanto tiene que ser sustituido con otras letras.

Tarea

Recibirá un carácter ABDEFGHIKLMNOPRSTUWYcomo entrada, y dará salida a la configuración correspondiente de las cinco agujas, sin desviar como |, desviada en sentido horario como /y desviada en sentido antihorario como \.

Casos de prueba

Esto cubre todas las entradas posibles.

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

Reglas / Requisitos

  • Cada presentación debe ser un programa completo o una función. Si es una función, debe ser ejecutable solo necesitando agregar la llamada a la función al final del programa. Cualquier otra cosa (por ejemplo, encabezados en C), debe incluirse.
  • Si es posible, proporcione un enlace a un sitio donde se pueda probar su programa.
  • Su programa no debe escribirle nada STDERR.
  • Las lagunas estándar están prohibidas.
  • Su programa puede generar resultados en cualquier caso, pero debe imprimirse (no una matriz o similar).

Puntuación

Los programas se puntúan según los bytes, en UTF-8 de forma predeterminada o en un conjunto de caracteres diferente de su elección.

Eventually, la respuesta con la menor cantidad de bytes ganará.

Envíos

Para asegurarse de que su respuesta se muestre, comience con un título, utilizando la siguiente plantilla de Markdown:

# Language Name, N bytes

¿Dónde Nestá el tamaño de su envío? Si mejora su puntaje, puede mantener los puntajes antiguos en el título, tachándolos. Por ejemplo:

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

Si desea incluir varios números en su encabezado (por ejemplo, porque su puntaje es la suma de dos archivos o desea enumerar las penalizaciones de la bandera del intérprete por separado), asegúrese de que el puntaje real sea el último número en el encabezado:

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

También puede hacer que el nombre del idioma sea un enlace que luego aparecerá en el fragmento de la tabla de clasificación:

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

Tabla de clasificación

Aquí hay un fragmento de pila para generar una tabla de clasificación regular y una descripción general de los ganadores por idioma.

Mostrar fragmento de código

code-golf ascii-art kolmogorov-complexity Monja permeable
fuente

Respuestas:

6

C, 124 107 98 bytes

Como una función:

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

Esto funciona mediante la rotación de la cuadrícula 45 grados y mirando hacia arriba la fila / columna desde el bloque resultante.

Como un ejecutable completo (107 bytes):

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 ejecutable completo alternativo: (mismo bytecount pero toma entrada de stdin e incluye nueva línea después de la salida)

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

Descompostura:

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
}

Desglose alternativo:

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
}

Bonificación: extensión 0-9 de la página de 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);}

Bonificación adicional: un programa completo (si es desordenado) para codificar y decodificar mensajes:

#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
fuente
5

CJam, 42 bytes

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

Pruébalo aquí

Aunque hay mucha estructura en las salidas, no estoy completamente seguro, pero puedo calcular los resultados de manera eficiente (en términos de bytes). Entonces, esta sigue siendo una tabla de búsqueda, pero estoy generando la lista de posibles configuraciones de agujas a través de permutaciones de la lista [0 1 2 3 4].

Martin Ender
fuente
3

MATL , 50 bytes

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

Pruébalo en línea!

Explicación breve

El código descomprime la cadena mostrada ( '!#$...J~v') en una cadena que contiene \, |y /; lo reforma en una matriz donde cada columna corresponde a una letra; e indexa esa matriz con el carácter de entrada.

Larga explicación

La cadena comprimida se ha obtenido (fuera de línea) usando codificación base-3 a base-95. Los datos del desafío se han organizado en una larga cadena de \, |y /, donde cada grupo de 5caracteres corresponde a una letra. Esta cadena se interpreta como la representación en base 3 de algún número grande, que se convierte en base 95, utilizando todos los caracteres ASCII imprimibles como dígitos. El resultado es la cadena comprimida que aparece en el código ( '!#$...J~v').

El programa se inicia descomprimir esta cadena, es decir, la conversión de base 95 a la base-3 con el alfabeto \, |, /. La cadena descomprimida se reforma en una matriz de caracteres 2D de 5 filas, en la que cada columna representa una letra. Llamemos a esta matriz Λ. Esta matriz se indexará utilizando el punto de código ASCII de la letra de entrada.

La matriz Λincluye dos trucos:

  1. Se ha llenado con valores ficticios para las cinco letras que faltan entre Ay Y;
  2. Comienza con L(no A) y luego continúa circularmente.

Los motivos de estos dos trucos son los siguientes:

  1. La letra Atiene un punto de código 65. La última letra que debe manejarse es Y, con punto de código 89. Por lo tanto, debemos manejar un rango de 25valores, incluso si Cno existen algunos intermedios (como la letra ). Para facilitar la indexación, las cinco letras que faltan entre Ay Yse han rellenado con una representación ficticia, por lo que tienen una columna Λ. Por lo tanto, Λtiene un tamaño de 5 × 25.

  2. Se utiliza indexación modular. Entonces letra Ao número 65es lo mismo que 65 mod 25, eso es 15. Por lo tanto, Adebe estar en la columna 15de Λ, Ben la columna 16, ... y Yen la columna 14.

Código comentado

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

Python 2, 172 152 151 79 bytes

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

Sin algoritmo, solo una tabla de búsqueda.

¡Ahorró 20 bytes gracias a @LeakyNun!

¡Ahorré un byte gracias a @TheBikingViking!

¡Ahorré la friolera de 72 bytes gracias a @Keeta!

Cobre
fuente
Puede usar en findlugar de indexpara -1 byte.
TheBikingViking
2
Si aprovecha la superposición de las barras, puede reducir en 72 caracteres a algo como lambda x: r '/ ||| \ / ||| / \ ||| / | \ || / || \ | / || '[' APONM LKIHY GFEWU DBTSR'.find (x):] [: 5]
Keeta - readmitir a Monica el
1

JavaScript (ES6), 97 89 bytes

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

Editar: guardado 3 bytes al cambiar a una tabla de búsqueda que no necesita relleno. Ahorró 5 bytes configurando elementos de la matriz en lugar de intentar editar una cadena.

Explicación: La tabla ABEHMDFINRGKOSULPTWYestá organizada de modo que si la divide en 5 grupos de 4 letras adyacentes, cada letra del grupo está en la misma /inclinación del diagrama, mientras que si la divide en 5 grupos tomando el módulo de índice 5, cada La letra del grupo está en la misma \inclinación en el diagrama. Estos últimos grupos están en orden inverso, pero eso se maneja fácilmente restando 4.

Neil
fuente
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)="/"

El byte final es el enterque se genera automáticamente End Function. Con agradecimientos a esquema ideado por @Dave .

Invocar en una hoja de cálculo o en una ventana VBA Inmediata, por ejemplo, con ?v("K")

Joffan
fuente
0

Mathematica, 129 bytes

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

Función anónima. Toma una cadena como entrada y devuelve una cadena que representa su código como salida. Utiliza un esquema de codificación relativamente simple.

LegionMammal978
fuente
0

Pyth, 27 bytes

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

Reemplace los escapes \x94,\x18 con los bytes correspondientes.

Pruébalo en línea

Cómo funciona

@                                      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

Sin usar ninguna tabla de búsqueda codificada.

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

Pruébalo en línea

Cómo funciona

@                                    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
fuente
0

Pitón 2, 115 111 bytes

Esta es una implementación simple, pero podría usar algo de golf. Sugerencias bienvenidas.

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

Sin golf:

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
fuente
0

C, 78 bytes

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

La versión que se muestra es ASCII para imprimir, 79 bytes. El segundo\\ puede ser reemplazado por cualquier byte único que tenga los mismos últimos 6 bits que el \carácter 0x5C: 0x1C (si su compilador lo permite), 0x9C o 0xDC.

El carácter de entrada se busca en la cadena mágica que contiene valores para Aa Y(incluyendo espacios para los caracteres no admitidos CJQVXel carácter de la tabla de consulta se interpreta como la superposición de cinco códigos de 2 bits donde.):

01 = /   10 = \    00 or 11 = |

Código comentado en programa de prueba

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

Explicación:

Las posiciones de las agujas desviadas se asignan a 0..4, y se consideran como un número de base 5 (2 dígitos). Para AL, los números son "tal cual"; para MZ, agregue 25 al número. El mapa es de variables aa w.

Dado el número correspondiente a la letra, use su representación de base 5: el dígito 5 para la primera aguja, el dígito 1 para la segunda aguja y el dígito 25 para las direcciones de las agujas.

Un programa para codificar una cadena completa, en lugar de un carácter, es solo un poco más largo: 172 bytes.

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
fuente