Télégraphe Cooke et Wheatstone, cinq aiguilles

20

Définition

Selon Wikipedia :

Le télégraphe de Cooke et Wheatstone était un premier système de télégraphe électrique datant des années 1830 inventé par l'inventeur anglais William Fothergill Cooke et le scientifique anglais Charles Wheatstone. C'était le premier système télégraphique mis en service commercial. Le récepteur se composait d'un certain nombre d'aiguilles qui pouvaient être déplacées par des bobines électromagnétiques pour pointer vers des lettres sur une planche. Cette fonctionnalité a été appréciée par les premiers utilisateurs qui ne voulaient pas apprendre les codes et les employeurs qui ne voulaient pas investir dans la formation du personnel.

Cela fonctionne comme ceci:

Schéma du télégraphe de Cooke et Wheatstone, cinq aiguilles

Au milieu se trouvent cinq aiguilles, qui peuvent être déviées dans le sens des aiguilles d'une montre (comme c'est le cas de l'aiguille du milieu) ou dans le sens inverse des aiguilles d'une montre (comme c'est le cas de la dernière aiguille).

Dans l'image ci-dessus, les deux aiguilles déviées pointent vers la lettre G, ce qui signifie que la lettre transmise / reçue est la lettre G.

Notez que les lettres C, J, Q, V, X, Zmanquent et doivent donc être remplacés par d' autres lettres.

Tâche

Vous recevrez un caractère en ABDEFGHIKLMNOPRSTUWYentrée et vous produirez la configuration correspondante des cinq aiguilles, avec unfléchi comme |, dévié dans le sens horaire comme /, et dévié dans le sens anti-horaire comme \.

Cas de test

Cela couvre toutes les entrées possibles

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

Règles / exigences

  • Chaque soumission doit être soit un programme complet soit une fonction. S'il s'agit d'une fonction, elle doit être exécutable en n'ajoutant que l'appel de fonction au bas du programme. Tout autre élément (par exemple, en-têtes en C) doit être inclus.
  • Si c'est possible, fournissez un lien vers un site où votre programme peut être testé.
  • Votre programme ne doit rien écrire STDERR.
  • Les échappatoires standard sont interdites.
  • Votre programme peut sortir dans tous les cas, mais il doit être imprimé (pas un tableau ou similaire).

Notation

Les programmes sont notés en octets, en UTF-8 par défaut ou dans un jeu de caractères différent de votre choix.

Eventually, la réponse avec le moins d'octets gagnera.

Soumissions

Pour vous assurer que votre réponse apparaît, veuillez commencer votre réponse avec un titre, en utilisant le modèle Markdown suivant:

# Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores dans le titre, en les rayant. Par exemple:

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

Si vous souhaitez inclure plusieurs nombres dans votre en-tête (par exemple, parce que votre score est la somme de deux fichiers ou que vous souhaitez répertorier les pénalités de drapeau d'interprète séparément), assurez-vous que le score réel est le dernier numéro de l'en-tête:

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

Vous pouvez également faire du nom de la langue un lien qui apparaîtra ensuite dans l'extrait de classement:

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

Classement

Voici un extrait de pile pour générer à la fois un classement régulier et un aperçu des gagnants par langue.

Afficher l'extrait de code

code-golf ascii-art kolmogorov-complexity Leaky Nun
la source

Réponses:

6

C, 124 107 98 octets

En tant que fonction:

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

Cela fonctionne en utilisant la rotation de la grille de 45 degrés et en recherchant la ligne / colonne du bloc résultant.

En tant qu'exécutable complet (107 octets):

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 exécutable complet alternatif: (même octet mais prend l'entrée de stdin et inclut la nouvelle ligne après la sortie)

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

Panne:

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
}

Ventilation alternative:

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: extension 0-9 depuis la page 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 programme complet (s'il est en désordre) pour l'encodage et le décodage des messages:

#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
la source
5

CJam, 42 octets

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

Testez-le ici

Bien qu'il y ait beaucoup de structure dans les sorties, je ne suis pas encore tout à fait sûr de pouvoir calculer les résultats efficacement (en termes d'octets). Il s'agit donc toujours d'une table de recherche, mais je génère la liste des configurations d'aiguille possibles via les permutations de la liste [0 1 2 3 4].

Martin Ender
la source
3

MATL , 50 octets

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

Essayez-le en ligne!

Brève explication

Le code décompresse la chaîne affichée ( '!#$...J~v') en une chaîne contenant \, |et /; le remodèle en un tableau où chaque colonne correspond à une lettre; et indexe ce tableau avec le caractère d'entrée.

Longue explication

La chaîne compressée a été obtenue (hors ligne) en utilisant le codage base-3 à base-95. Les données du défi ont été organisées en une longue chaîne de \, |et /, où chaque groupe de 5caractères correspond à une lettre. Cette chaîne est interprétée comme la représentation en base 3 d'un grand nombre, qui est convertie en base 95, en utilisant tous les caractères ASCII imprimables sous forme de chiffres. Le résultat est la chaîne compressée qui apparaît dans le code ( '!#$...J~v').

Le programme démarre décompression cette chaîne, qui est, la conversion de la base 95 à la base de 3-alphabet \, |, /. La chaîne décompressée est remodelée en un tableau de caractères 2D à 5 lignes, dans lequel chaque colonne représentant une lettre. Appelons ce tableau Λ. Ce tableau sera indexé à l'aide du point de code ASCII de la lettre d'entrée.

Le tableau Λcomprend deux astuces:

  1. Il a été rempli de valeurs fictives pour les cinq lettres manquantes entre Aet Y;
  2. Il commence par L(non A) puis se déroule de façon circulaire.

Les raisons de ces deux astuces sont les suivantes:

  1. La lettre Aa un point de code 65. La dernière lettre à traiter est Y, avec point de code 89. Nous devons donc gérer une plage de 25valeurs, même si certaines intermédiaires (comme la lettre C) n'existent pas. Pour faciliter l'indexation, les cinq lettres manquantes entre Aet Yont été remplies avec une représentation fictive, donc elles ont une colonne dedans Λ. Ainsi, Λa une taille 5 × 25.

  2. L'indexation modulaire est utilisée. Donc, la lettre Aou le chiffre 65est le même que 65 mod 25, c'est-à-dire 15. Par conséquent, Adoit être dans la colonne 15de Λ, Bdans la colonne 16, ... et Ydans la colonne 14.

Code commenté

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

Python 2, 172 152 152 151 79 octets

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

Aucun algorithme, juste une table de recherche.

20 octets enregistrés grâce à @LeakyNun!

Un octet enregistré grâce à @TheBikingViking!

A sauvé un énorme 72 octets grâce à @Keeta!

Cuivre
la source
Vous pouvez utiliser findau lieu de indexpour -1 octet.
TheBikingViking
2
Si vous profitez du chevauchement des barres obliques, vous pouvez réduire de 72 caractères à quelque chose comme lambda x: r '/ ||| \ / ||| / \ ||| / | \ || / || \ | / || '[' APONM LKIHY GFEWU DBTSR'.find (x):] [: 5]
Keeta - réintègre Monica
1

JavaScript (ES6), 97 89 octets

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

Modifier: enregistré 3 octets en basculant vers une table de recherche qui n'a pas besoin de remplissage. Enregistré 5 octets en définissant des éléments de tableau au lieu d'essayer de modifier une chaîne.

Explication: Le tableau ABEHMDFINRGKOSULPTWYest organisé de sorte que si vous le divisez en 5 groupes de 4 lettres adjacentes, chaque lettre du groupe est sur la même /pente dans le diagramme, tandis que si vous le divisez en 5 groupes en prenant l'index modulo 5, puis chacun lettre dans le groupe est sur la même \pente dans le diagramme. Ces derniers groupes sont dans l'ordre inverse, mais cela est facilement géré en soustrayant de 4. (Organiser le tableau de sorte que les anciens groupes soient dans l'ordre inverse coûte plus cher à corriger.)

Neil
la source
1

VBA, 106 octets

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

L'octet final est celui enterqui se génère automatiquement End Function. Avec des remerciements au schéma @Dave conçu .

Appelez dans une feuille de calcul ou dans VBA Fenêtre immédiate, par exemple avec ?v("K")

Joffan
la source
0

Mathematica, 129 octets

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

Fonction anonyme. Prend une chaîne en entrée et renvoie une chaîne représentant son code en sortie. Utilise un schéma de codage relativement simple.

LegionMammal978
la source
0

Pyth, 27 octets

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

Remplacer les évasions \x94, \x18les octets correspondants.

Essayez-le en ligne

Comment ça fonctionne

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

Sans utiliser de tables de recherche codées en dur.

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

Essayez-le en ligne

Comment ça fonctionne

@                                    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
la source
0

Python 2, 115 111 octets

Il s'agit d'une implémentation simple, mais elle pourrait utiliser du golf. Suggestions bienvenues.

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

Non 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
la source
0

C, 78 octets

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

la version indiquée est entièrement imprimable en ASCII, 79 octets. Le second \\peut être remplacé par n'importe quel octet unique ayant les mêmes 6 derniers bits que le\ caractère 0x5C: 0x1C (si votre compilateur le permet), 0x9C ou 0xDC.

Le caractère d'entrée est recherché dans la chaîne magique qui contient les valeurs de Ato Y(y compris les espaces pour les caractères non pris en charge CJQVX.) Le caractère de la table de recherche est interprété comme cinq codes 2 bits qui se chevauchent où:

01 = /   10 = \    00 or 11 = |

Code commenté dans le programme de 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);
}
Level River St
la source
0

Rubis, 159 octets

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

Explication:

Les positions des aiguilles déviées sont mappées à 0..4 et considérées comme un nombre en base 5 (2 chiffres). Pour AL, les nombres sont «tels quels»; pour MZ, ajoutez 25 au nombre. La carte est de variables aà w.

Étant donné le nombre correspondant à la lettre, utilisez sa représentation en base 5: le chiffre 5s pour la première aiguille, le chiffre 1s pour la deuxième aiguille et le chiffre 25s pour les directions des aiguilles.

Un programme pour encoder une chaîne entière, au lieu d'un caractère, est juste un peu plus long: 172 octets.

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
la source