C'est la suite de ce défi d' Adnan . Si vous aimez ce défi, il y a de fortes chances que vous aimiez aussi l'autre. Vérifiez-le!

Un test à choix multiples avec 8 questions chacun avec 4 choix pourrait avoir les réponses: BCADBADA. Converti en quatre tableaux différents, avec vrai et faux si la lettre actuelle est la réponse, elle ressemblera à ceci

Q#: 1  2  3  4  5  6  7  8
    B  C  A  D  B  A  D  A
A: [0, 0, 1, 0, 0, 1, 0, 1]
B: [1, 0, 0, 0, 1, 0, 0, 0]
C: [0, 1, 0, 0, 0, 0, 0, 0]
D: [0, 0, 0, 1, 0, 0, 1, 0]

Cela peut être compressé en utilisant un peu de logique. Chacun des choix A, B, Cet Dpeut être représenté par deux valeurs vrai / faux ci - dessous:

A: 1 0
B: 0 1
C: 0 0
D: 1 1

En utilisant cette logique, nous pouvons compresser les quatre vecteurs ci-dessus à seulement deux:

 1  2  3  4  5  6  7  8
 B  C  A  D  B  A  D  A
[0, 0, 1, 1, 0, 1, 1, 1]
[1, 0, 0, 1, 1, 0, 1, 0]

Autrement dit, la solution à votre test est simplement: 00110111, 10011010. En les concaténant, nous obtenons le nombre binaire 0011011110011010, ou 14234en décimal. Utilisez cette valeur décimale pour tricher sur votre test!

Défi

Prenez un nombre Ndans la plage (inclusive) [0, 65535]et sortez une chaîne avec la réponse au test à choix multiple.

Cas de test:

14234
BCADBADA

38513
ABBDCAAB    

0
CCCCCCCC

120
CBBBBCCC

65535
DDDDDDDD

39253
ABCDABCD

La sortie peut être en majuscules ou en minuscules, mais vous ne pouvez pas utiliser d'autres symboles.

Gelée , 14 octets

d⁹+⁹BZḄḊị“BADC

Essayez-le en ligne! ou vérifiez tous les cas de test .

Comment ça marche

d⁹+⁹BZḄḊị“BADC  Main link. Argument: n

d⁹              Divmod 256; yield [n : 256, n % 256].
  +⁹            Add 256; yield [n : 256 + 256, n % 256 + 256].
    B           Binary; convert both integers to base 2.
     Z          Zip; group the quotient bits with corresponding remainder bits.
      Ḅ         Unbinary; convert from base 2 to integer.
       Ḋ        Dequeue; discard the first integer, which corresponds to the
                dummy value introduced by adding 256 to quotient and remainder.
        ị“BADC  Index into that string, mapping [1, 2, 3, 0] to "BADC".

05AB1E , 19 18 16 octets

Code:

žH+b¦2äøC’c‰±’sè

Utilise l' encodage CP-1252 . Essayez-le en ligne!

Explication:

Tout d'abord, nous ajoutons 65536au nombre ( žHest une constante définie pour 65536), qui est également 10000000000000000en binaire. Il s'agit de remplir le nombre avec des zéros. Prenons le nombre 14234comme exemple. 14234 + 65536est égal à 79770. Qui en binaire est:

10011011110011010

Nous supprimons le premier caractère, résultant en:

0011011110011010

Nous avons divisé la chaîne en deux morceaux en utilisant 2ä:

00110111, 10011010

Après cela, nous compressons le tableau avec ø:

01, 00, 10, 11, 01, 10, 11, 10

Les reconvertir en décimal (en utilisant C) entraîne:

1, 0, 2, 3, 1, 2, 3, 2

Maintenant, il nous suffit de l'indexer avec la chaîne cbad. La version compressée de cette chaîne est ’c‰±’, qui peut également être testée ici . Enfin, nous obtenons les caractères à l'index du tableau ci-dessus. Pour l'exemple ci-dessus, cela se traduit par:

1, 0, 2, 3, 1, 2, 3, 2
b  c  a  d  b  a  d  a

JavaScript (ES6), 55 48 octets

f=(n,i=8)=>i--?"CBAD"[n>>i&1|n>>i+7&2]+f(n,i):''

console.log(f(14234)); // BCADBADA
console.log(f(38513)); // ABBDCAAB
console.log(f(0));     // CCCCCCCC
console.log(f(120));   // CBBBBCCC
console.log(f(65535)); // DDDDDDDD
console.log(f(39253)); // ABCDABCD

Version non récursive (55 octets)

En utilisant une expression régulière, nous pouvons faire:

n=>"76543210".replace(/./g,i=>"CBAD"[n>>i&1|n>>+i+7&2])

Python 2, 53 octets

f=lambda n,k=8:k*'_'and f(n/2,k-1)+'CBAD'[n>>7&2|n&1]

Testez-le sur Ideone .

Assemblage CP-1610 , 24 DECLE (30 octets)

Ce code est destiné à être exécuté sur une Intellivision . ⁽¹⁾

Un opcode CP-1610 est codé avec une valeur de 10 bits, connue sous le nom de «DECLE». La fonction réelle est de 24 DECLEs, commençant à $4809et se terminant à $4820.

Les registres CPU sont cependant une largeur de 16 bits, il soutiendra toute valeur d'entrée 0x0000.. 0xFFFF.

                            ROMW  10            ; use 10-bit ROM
                            ORG   $4800         ; start program at address $4800
4800 0002                   EIS                 ; enable interrupts (to enable display)

                    ;; ---- usage example
4801 0001                   SDBD                ; load parameter in R0
4802 02B8 009A 0037         MVII  #14234, R0    ;
4805 0004 0148 0009         CALL  cheat         ; call function
4808 0017                   DECR  PC            ; infinite loop

                    ;; ---- 'Cheat Your Test' function
                    cheat   PROC  

4809 0082                   MOVR  R0,     R2    ; copy R0 to R2
480A 0040                   SWAP  R0            ; swap LSB/MSB in R0
480B 02BC 0214              MVII  #$214,  R4    ; R4 = pointer to 2nd row of screen memory

480D 01DB           @@loop  CLRR  R3            ; clear R3
480E 0052                   RLC   R2            ; extract highest bit of R2 to carry
480F 0053                   RLC   R3            ; inject carry into R3
4810 0050                   RLC   R0            ; extract highest bit of R0 to carry
4811 0053                   RLC   R3            ; inject carry into R3
4812 0001                   SDBD                ; add pointer to lookup table to R3
4813 02FB 001D 0048         ADDI  #@@tbl, R3    ;
4816 029B                   MVI@  R3,     R3    ; read character value
4817 0263                   MVO@  R3,     R4    ; write it to screen memory (also does R4++)
4818 037C 021C              CMPI  #$21C,  R4    ; 8 characters written? ...
481A 0225 000E              BLT   @@loop        ; ... if not, jump to @@loop

481C 00AF                   JR    R5            ; return

481D 011F 0117      @@tbl   DECLE $11F, $117    ; characters 'B', 'C', 'A' and 'D'
481F 010F 0127              DECLE $10F, $127    ; in white, using the built-in font

                            ENDP

Sortie

_{(1) Étant entendu qu'au moins un compilateur, plusieurs émulateurs et des fichiers ROM de remplacement sans droit d'auteur sont disponibles gratuitement, je pense que cela ne contrevient à aucune règle de soumission PPCG. Mais faites-moi savoir si je me trompe.}

CJam , 22 octets

ri2bG0e[8/:.{1$=)^'A+}

Essayez-le en ligne!

Explication

Propulsé par la magie ...

Le mappage des paires de bits aux lettres dans ce défi est un peu arbitraire. Si nous représentons ABCDpar 0, 1, 2, 3(afin que nous puissions simplement les ajouter au caractère A), nous voulons le mappage suivant:

i1   i2   o
0    0    2
0    1    1
1    0    0
1    1    3

Ce mappage peut être calculé avec une petite formule magique:, ((i1 == i2) + 1) ^ i1où le contrôle d'égalité renvoie 0ou 1. Consultez le tableau suivant, où chaque colonne correspond à une entrée, chaque ligne correspond à une opération et chaque cellule affichera la pile à ce point:

[i1, i2]:  [0, 0]     [0, 1]     [1, 0]     [1, 1]
copy i1:   [0, 0, 0]  [0, 1, 0]  [1, 0, 1]  [1, 1, 1]
equals:    [0, 1]     [0, 0]     [1, 0]     [1, 1]
inc:       [0, 2]     [0, 1]     [1, 1]     [1, 2]
xor:       [2]        [1]        [0]        [3]

Dans cet esprit, voici la répartition complète du code source:

ri     e# Read input, convert to integer.
2b     e# Get binary representation.
G0e[   e# Pad to 16 bits with zeros.
8/     e# Split into two halves of 8 bits each.
:.{    e# For each pair of bits, i1 and i2...
  1$   e#   Copy i1.
  =    e#   Check equality with i2.
  )    e#   Increment.
  ^    e#   Bitwise XOR.
  'A+  e#   Add to 'A'
}

Une solution alternative avec le même nombre d'octets qui est décidément moins magique:

ri2bG0e[8/z2fb"CBAD"f=

Et dans le cas où cela est utile à n'importe qui, si vous redéfinissez les bits i1et i2en un seul nombre (c'est-à-dire lorsque vous voulez le mappage 0 -> 2, 1 -> 1, 2 -> 0, 3 -> 3), cela peut être calculé encore plus facilement car (~n - 1) & 3ou (~n - 1) % 4si votre langue obtient modulo sur des valeurs négatives à droite. Je pense que cela peut être écrit de manière concise comme 3&~-~ndans de nombreuses langues. Dans CJam, cela se révèle être un octet plus long, en raison de la conversion supplémentaire de la base 2.

PHP, 57 octets

for($i=8;$i--;)echo CBAD[($n=$argv[1])>>$i+7&2|$n>>$i&1];

Version sans opérateurs Bitwise 70 octets

for(;$i<8;)echo CABD[($s=sprintf("%016b",$argv[1]))[$i]+$s[8+$i++]*2];

Mathematica, 75 73 68 66 octets

StringPart["CBAD",#+##+1]&@@IntegerDigits[#,2,16]~Partition~8<>""&

Merci à @MartinEnder pour avoir économisé 2 octets.

Perl, 42 octets

Comprend +1 pour -n

Donnez votre avis sur STDIN:

perl -nE 'say+(A..D)[2-($`>>8-$_&257)%127]for/$/..8' <<< 39253

Juste le code:

say+(A..D)[2-($`>>8-$_&257)%127]for/$/..8

JavaScript, 113 93 90 88 octets

Un grand merci à @Neil pour m'avoir aidé à économiser 20 octets!
-3 octets grâce à @Cyoce

n=>{r="";b=("0".repeat(15)+n.toString(2)).slice(-16);for(i=0;i<8;i++)r+="CBAD"[parseInt(b[i]+b[i+8],2)];return r}

n=>{r="";b=(65536+n).toString(2).slice(1);for(i=0;i<8;i++)r+="CBAD"[+b[i+8]+2*b[i]];return r}

n=>eval('r="";b=(65536+n).toString(2).slice(1);for(i=0;i<8;i++)r+="CBAD"[+b[i+8]+2*b[i]]')

n=>eval('r="";b=n.toString(2).padStart(16,0);for(i=0;i<8;i++)r+="CBAD"[+b[i+8]+2*b[i]]')

Malheureusement, JavaScript ne dispose pas des fonctions telles que decbin, bindecet str_padque PHP a.

MATL, 16 octets

16&B8eXB'BADC'w)

Essayez-le en ligne!

ou vérifier tous les cas de test

Explication

        % Implicitly grab input
16&B    % Convert to binary string with at least 16 bits
8e      % Reshape the resulting string to have 8 rows and 2 columns
XB      % Convert each row from binary to decimal
'BADC'  % Push this string literal
w)      % Use the decimal numbers to index into this string (modular indexing)
        % Implicitly display the resulting string

Julia, 73 octets

Donne une fonction f prenant N en entrée et renvoyant la réponse sous forme de chaîne.

f(N)=(b=bin(N,16);join(["CBAD"[parse("0b$(b[i])$(b[i+8])")+1]for i=1:8]))

Essayez-le

Selon qu'un tableau de caractères compte comme une chaîne, on peut omettre la jointure ( 67 octets )

f(N)=(b=bin(N,16);["CBAD"[parse("0b$(b[i])$(b[i+8])")+1]for i=1:8])

Essayez-le

R, 110 octets

Entré avec une solution vectorisée dans R. Cela devrait probablement être golfable en proposant une conversion plus intelligente int en conversion binaire.

x=as.integer(intToBits(scan()));cat(LETTERS[1:4][match(paste0(x[16:9],x[8:1]),c("10","01","00","11"))],sep="")