Telégrafo de Cooke e Wheatstone, cinco agulhas

20

Definição

De acordo com a Wikipedia :

O telégrafo de Cooke e Wheatstone foi um antigo sistema de telégrafo elétrico datado da década de 1830, inventado pelo inventor inglês William Fothergill Cooke e pelo cientista inglês Charles Wheatstone. Foi o primeiro sistema de telégrafo a ser colocado em serviço comercial. O receptor consistia em várias agulhas que podiam ser movidas por bobinas eletromagnéticas para apontar para letras em um quadro. Esse recurso foi apreciado por usuários iniciais que não estavam dispostos a aprender códigos e por empregadores que não desejavam investir em treinamento de pessoal.

Funciona assim:

Esquema do telégrafo de Cooke e Wheatstone, de cinco agulhas

No meio, há cinco agulhas, que podem ser desviadas no sentido horário (como é o caso da agulha do meio) ou no sentido anti-horário (como é o caso da última agulha).

Na figura acima, as duas agulhas desviadas apontam para a letra G, o que significa que a letra que está sendo transmitida / recebida é a letra G.

Note-se que as letras C, J, Q, V, X, Zestão faltando e, portanto, tem que ser substituído por outras letras.

Tarefa

Você receberá um caractere ABDEFGHIKLMNOPRSTUWYcomo entrada e produzirá a configuração correspondente das cinco agulhas, com undeflected como |, defletido no sentido horário como /e defletido no sentido anti-horário como \.

Casos de teste

Isso cobre todas as entradas possíveis

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

Regras / Requisitos

  • Cada envio deve ser um programa ou uma função completa. Se for uma função, ela deve ser executável, bastando adicionar a chamada de função na parte inferior do programa. Qualquer outra coisa (por exemplo, cabeçalhos em C) deve ser incluída.
  • Se possível, forneça um link para um site onde seu programa possa ser testado.
  • Seu programa não deve escrever nada para STDERR.
  • As brechas padrão são proibidas.
  • Seu programa pode produzir em qualquer caso, mas deve ser impresso (não uma matriz ou similar).

Pontuação

Os programas são classificados de acordo com os bytes, em UTF-8, por padrão, ou com um conjunto de caracteres diferente de sua escolha.

Eventually, a resposta com o mínimo de bytes vencerá.

Submissões

Para garantir que sua resposta seja exibida, inicie-a com um título, usando o seguinte modelo de remarcação:

# Language Name, N bytes

onde Nestá o tamanho do seu envio. Se você melhorar sua pontuação, poderá manter as pontuações antigas no título, identificando-as. Por exemplo:

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

Se você quiser incluir vários números no cabeçalho (por exemplo, porque sua pontuação é a soma de dois arquivos ou você deseja listar as penalidades do sinalizador de intérpretes separadamente), verifique se a pontuação real é o último número no cabeçalho:

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

Você também pode transformar o nome do idioma em um link que será exibido no snippet da tabela de classificação:

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

Entre os melhores

Aqui está um snippet de pilha para gerar uma classificação regular e uma visão geral dos vencedores por idioma.

Mostrar snippet de código

code-golf ascii-art kolmogorov-complexity Freira Furada
fonte

Respostas:

6

C, 124 107 98 bytes

Como uma função:

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

Isso funciona girando a grade 45 graus e olhando a linha / coluna do bloco resultante.

Como um executável 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);}

Um executável completo alternativo: (o mesmo bytecount, mas recebe a entrada do stdin e inclui nova linha após a saída)

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

Demolir:

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
}

Repartição 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
}

Bônus: extensão 0-9 da página da 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);}

Bônus de bônus: um programa completo (se confuso) para mensagens de codificação e decodificação:

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

CJam, 42 bytes

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

Teste aqui

Embora exista muita estrutura nas saídas, ainda não tenho muita certeza de que posso calcular os resultados com eficiência (em termos de bytes). Portanto, essa ainda é uma tabela de pesquisa, mas estou gerando a lista de possíveis configurações de agulhas por meio de permutações da lista [0 1 2 3 4].

Martin Ender
fonte
3

MATL , 50 bytes

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

Experimente online!

Breve explicação

O código descompacta a string mostrada ( '!#$...J~v') em uma string contendo \, |e /; remodela-o em uma matriz onde cada coluna corresponde a uma letra; e indexa essa matriz com o caractere de entrada.

Explicação longa

A cadeia compactada foi obtida (offline) usando a codificação base 3 a base 95. Os dados do desafio foram organizados em uma longa sequência de \, |e /, em que cada grupo de 5caracteres corresponde a uma letra. Essa sequência é interpretada como a representação da base 3 de algum número grande, que é convertida em base 95, usando todos os caracteres ASCII imprimíveis como dígitos. O resultado é a sequência compactada que aparece no código ( '!#$...J~v').

O programa começa descompressão esta cadeia, ou seja, a conversão de base-95 para base-3 com alfabeto \, |, /. A sequência descompactada é remodelada em uma matriz de caracteres 2D de 5 linhas, na qual cada coluna representa uma letra. Vamos chamar essa matriz Λ. Essa matriz será indexada usando o ponto de código ASCII da letra de entrada.

A matriz Λinclui dois truques:

  1. Foi preenchido com valores fictícios para as cinco letras ausentes entre Ae Y;
  2. Começa com L(não A) e depois prossegue circularmente.

As razões para esses dois truques são as seguintes:

  1. A carta Apossui um ponto de código 65. A última letra que precisa ser manipulada é Y, com ponto de código 89. Portanto, precisamos lidar com uma faixa de 25valores, mesmo que alguns intermediários (como letra C) não existam. Para facilitar a indexação, as cinco letras ausentes entre Ae Yforam preenchidas com uma representação fictícia, para que elas tenham uma coluna Λ. Assim, Λtem tamanho 5 × 25.

  2. Indexação modular é usada. Portanto A, letra ou número 65é o mesmo 65 mod 25que é 15. Portanto, Aprecisa estar na coluna 15de Λ, Bna coluna 16, ... e Yna coluna 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
fonte
3

Python 2, 172 152 151 151 79 bytes

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

Nenhum algoritmo, apenas uma tabela de pesquisa.

Economizou 20 bytes graças a @LeakyNun!

Guardou um byte graças a @TheBikingViking!

Economizou 72 bytes graças ao @Keeta!

Cobre
fonte
Você pode usar em findvez de indexpara -1 byte.
TheBikingViking
2
Se você aproveitar a sobreposição das barras, poderá reduzir em 72 caracteres para algo como lambda x: r '/ ||| \ / ||| / \ ||| / | \ || / || \ | / || '[' APONM LKIHY GFEWU DBTSR'.find (x):] [: 5]
Keeta - reinstala Monica em
1

JavaScript (ES6), 97 89 bytes

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

Editar: salvou 3 bytes alternando para uma tabela de pesquisa que não precisa de preenchimento. Economizou 5 bytes configurando elementos da matriz em vez de tentar editar uma sequência.

Explicação: A tabela ABEHMDFINRGKOSULPTWYestá organizada para que, se você a dividir em 5 grupos de 4 letras adjacentes, cada letra do grupo estiver na mesma /inclinação do diagrama, enquanto que se você a dividir em 5 grupos, utilizando o módulo de índice 5, A letra do grupo está na mesma \inclinação do diagrama. Esses últimos grupos estão na ordem inversa, mas isso é facilmente subtraído de 4. (Organizar a tabela para que os grupos anteriores estivessem na ordem inversa custa mais para corrigir).

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

Byte final é o enterque gera automaticamente End Function. Com agradecimentos ao esquema @Dave concebido .

Invoque na planilha ou na janela Imediata do VBA, por exemplo, com ?v("K")

Joffan
fonte
0

Mathematica, 129 bytes

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

Função anônima. Pega uma sequência como entrada e retorna uma sequência que representa seu código como saída. Usa um esquema de codificação relativamente simples.

LegionMammal978
fonte
0

Pitão, 27 bytes

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

Substitua as fugas \x94,\x18 com os bytes correspondentes.

Experimente online

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

Pitão, 32 bytes

Sem usar nenhuma tabela de pesquisa codificada.

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

Experimente online

Como 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
fonte
0

Python 2, 115 111 bytes

Esta é uma implementação simples, mas poderia ser útil. Sugestões são bem-vindas.

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

C, 78 bytes

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

A versão mostrada é toda ASCII imprimível, 79 bytes. O segundo \\pode ser substituído por qualquer byte único com os mesmos últimos 6 bits que o\ caractere 0x5C: 0x1C (se o seu compilador permitir), 0x9C ou 0xDC.

O caractere de entrada é procurado na string mágica que contém valores para Aa Y(incluindo espaços para os caracteres não suportadosCJQVX O carácter da tabela de consulta é interpretado como cinco códigos sobrepostos 2-bit, em que.):

01 = /   10 = \    00 or 11 = |

Código comentado no programa de teste

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

Explicação:

As posições das agulhas desviadas são mapeadas para 0..4 e pensadas como um número de base 5 (2 dígitos). Para AL, os números são "como estão"; para MZ, adicione 25 ao número. O mapa é de variáveis aparaw .

Dado o número correspondente à letra, use sua representação de base 5: o dígito 5s para a primeira agulha, o dígito 1s para a segunda agulha e o dígito 25s para as direções das agulhas.

Um programa para codificar uma sequência inteira, em vez de um caractere, é um pouco mais longo: 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
fonte