introduction

Remarque: ce n'est pas une sorte de méthode pour encourager la tricherie. Comme l'a déjà dit Cᴏɴᴏʀ O'B said, étudier est la meilleure solution pour réussir un test: 3.

Considérez les réponses suivantes au test à choix multiples:

ABCBCAAB

Voici un tableau qui indique si les réponses correspondent:

    A B C B C A A B

A   1 0 0 0 0 1 1 0
B   0 1 0 1 0 0 0 1
C   0 0 1 0 1 0 0 0

Cela nous donne les chiffres suivants:

10000110, 01010001, 00101000

Le défi est d'imprimer ces nombres binaires. Mais il est important de voir quelles lettres sont utilisées dans le test à choix multiple. Par exemple:

ABCDCDBCDABC

Cette lettre la plus haute est D, qui est la 4ème lettre de l'alphabet . Par conséquent, nous devons sortir 4 nombres binaires différents . À savoir:

100000000100, 010000100010, 001010010001, 000101001000

Notez que vous devez regarder la lettre la plus haute . Prenons l'exemple suivant:

AACCACAC

Bien que le Bne soit pas utilisé, nous devons afficher le résultat binaire pour B. Cela signifie que la réponse serait:

11001010, 00000000, 00110101

Tâche

Étant donné les réponses à un test à choix multiples, sortez les nombres binaires. Vous pouvez supposer que l'entrée ne sera pas vide et ne contiendra que les lettres[A-Z] . Au lieu de uns et de zéros, vous pouvez également utiliser true et false.

Cas de test:

Input: ABBBABABA
Output: 100010101, 011101010

Input: AAAAAAAAA
Output: 111111111

Input: AFGHEEHFD
Output: 100000000 000000000 000000000 000000001 000011000 010000010 001000000 000100100

Input: Z
Output: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1

Input: ABCDCDBCDABC
Output: 100000000100, 010000100010, 001010010001, 000101001000

C'est du code-golf , donc la soumission avec le moins d'octets gagne!

Pyth, 12 octets

mqLdzfsgRTzG

Sorties sous forme de tableau imbriqué de booléens.

                Implicit: z=input
m               Map lambda d:
 qLdz            map equal-to-d over z
     f           over all letters T in the
           G     lowercase alphabet for which
      s           At least one char in z
       gRTz       >= T.

Essayez-le ici .

Python 3, 71

Enregistré 22 octets grâce à Ogaday.
Enregistré 3 octets grâce à DSM.

Enregistré un tas d'octets grâce à un tableau de bools étant valide.

*k,=map(ord,input())
x=65
while x<=max(k):print([v==x for v in k]);x+=1

Prend l'entrée de ligne de commande en majuscule.

PowerShell, 95 94 73 octets

param([char[]]$a)0..(($a|sort)[-1]-65)|%{$d=$_;-join($a|%{+!($_-$d-65)})}

Prend l'entrée comme une chaîne majuscule, mais la transforme immédiatement [char[]]. Nous bouclons ensuite de 0..à la valeur maximale de $aprise par ordre alphabétique (d'où la -65conversion de ASCII). Par exemple, avec ADCEB, cela peut être considéré comme une boucle de Aà E.

À chaque itération, nous définissons une variable d'aide $dégale à la valeur alphabétique actuelle (et non ASCII). Nous bouclons ensuite par tous $a, chaque fois que la mise soit 0ou 1sur le pipeline, selon que $_-$d-65est truthy ou Falsey ( à savoir si nous sommes dans la « fente » à droite). Cela fonctionne car toute valeur non nulle dans PowerShell est véridique, ce qui signifie que si notre lettre actuelle $_"n'égale" pas l'emplacement dans lequel nous nous trouvons $d, alors !c'est le cas $false, ou 0.

Chacun de ces tableaux de 0s et 1s est ensuite -joinédité ensemble et remis sur le pipeline. Lorsque la boucle externe se termine, nous avons un tableau de chaînes, qui affichera une chaîne par ligne.

Exemples

PS C:\Tools\Scripts\golfing> .\preparing-a-multiple-choice-test.ps1 ABCDEFGH
10000000
01000000
00100000
00010000
00001000
00000100
00000010
00000001

PS C:\Tools\Scripts\golfing> .\preparing-a-multiple-choice-test.ps1 AFGHEEHFD
100000000
000000000
000000000
000000001
000011000
010000010
001000000
000100100

_{Edit 1 - enregistré un octet en utilisant Boolean-not au lieu de -eq
Edit 2 - enregistré 21 octets supplémentaires en éliminant le tableau supplémentaire $ b}

LabVIEW, 30 22 20 LabVIEW Primitives

Passe de az jusqu'à ce que la somme de tous les bools soit égale à la longueur d'entrée. Transforme ensuite les bools en nombres.

Prend maintenant directement le max au lieu de vérifier la somme booléenne.

Puisque les bools 2D sont viables maintenant, j'économise 2 primitives en sortant le fil vert devant ?1:0pourrait le refaire mais je suis trop paresseux ...

Cjam, 25 octets

l{'A-i}%_:e>),\f{f=", "}

Soupir,

Explication

l{'A-i}%_:e>),\f{f=", "}
l                        e# get the input
 {'A-i}%                 e# get the normalized array
        _:e>             e# get the maximum value
            ),           e# create the array from 1..N
              \f{      } e# map over the created array
                 f=      e# 1 if match, 0 if not
                   ", "  e# add separator

Haskell, 46 34 octets

g x=(<$>x).(==)<$>['A'..maximum x]

Exemple d'utilisation: g "ACDC"-> [[True,False,False,False],[False,False,False,False],[False,True,False,True],[False,False,True,False]].

Comment ça fonctionne:

        <$>['A'..maximum x]   -- for every letter from A to the highest letter in x
<$>x                          -- loop over x and
      ==                      -- compare the letter with the current element in x
                              -- which results in a boolean          

Pyth, 20 19 17 15 14 octets

VhxGeSzmq@GNdz

Explication:

               - autoassign z = input()
V              - For N in range(V)
 hxGeSz
    eSz        - max(z)
  xG           - lowercase_alphabet.index(^)
 h             - +1
       mq@GNdz
       m     z - [V for d in z]
         @GN   - lowercase_alphabet[N]
        q   d  - is_equal(^, ^^)
               - print "".join(^)

Produit un tableau 2D de bools

Essayez-le ici

ES6, 92 octets

s=>[..."ABCDEFGHIJKLMNOPQRSTUVWXYZ"].map(c=>[...s].map(m=>m==c&&!!(l=n),n++),n=0).slice(0,l)

Renvoie un tableau de tableaux de fausses et vraies. Si vous préférez un tableau de chaînes de zéros et de uns, alors pour 97 octets:

s=>[..."ABCDEFGHIJKLMNOPQRSTUVWXYZ"].map(c=>s.replace(/./g,m=>m==c?(l=n,1):0,n++),n=0).slice(0,l)

Octave, 19 octets

@(s)s==[65:max(s)]'

Utilise la diffusion automatique d'Octave sur la plage Ajusqu'à l'élément max dans l'entrée pour produire un tableau booléen 2D d'éléments correspondants.

Exemple:

Key = ABCDCDBCDABC

ans =

   1   0   0   0   0   0   0   0   0   1   0   0
   0   1   0   0   0   0   1   0   0   0   1   0
   0   0   1   0   1   0   0   1   0   0   0   1
   0   0   0   1   0   1   0   0   1   0   0   0

Essayez-le ici sur ideone .

Lua, 208 189 octets

C'était difficile à Lua, comme d'habitude, nous devons tout faire à partir de zéro, et cela prend beaucoup de place! Ce programme prend une chaîne en argument et affiche le résultat :).

Edit: @Adnan m'a dit que nous sommes maintenant autorisés à retourner une matrice de booléens, alors voici une nouvelle version! C'est maintenant une fonction qui prend une chaîne de caractères en majuscule et retourne la matrice :).

function f(x)a={}b={}for i=1,#x do a[i]=x:sub(i,i)end table.sort(a)for i=1,a[#a]:byte()-64 do b[i]={}end x:gsub(".",function(c)for i=1,#b do z=b[i]z[#z+1]=i+64==c:byte()end end)return b end

Ancienne version de 208 octets

C'est celui qui fonctionne avec les résultats d'argument et d'impression.

a={}b={}x=arg[1]for i=1,#x do a[i]=x:sub(i,i)end table.sort(a)for i=1,a[#a]:byte()-64 do b[i]=""end x:gsub(".",function(c)for i=1,#b do b[i]=b[i]..(i+64==c:byte()and"1"or"0")end end)print(table.concat(b,","))

Non golfé et explications

function f(x)
a={}                   -- We need 2 arrays, and while b=a would have been shorter
b={}                   -- arrays in lua are passed by pointer, so it wouldn't have worked

for i=1,#x             -- iterate over the inpute to transform the string
do                     -- into an array
  a[i]=x:sub(i,i)      -- with each cells containing a characyer
end
table.sort(a)          -- sort the array/string

for i=1,               -- iterate n times were n is the place in the alphabet
       a[#a]:byte()-64 -- of the last element of the (sorted) array a
do
  b[i]={}              -- initialise cells in b up to n with empty arrays
end                    -- a cell's index is the position of a letter in the alphabet

x:gsub(".",function(c) -- for each character in the input
  for i=1,#b           -- iterate over each cells in b
  do
    z=b[i]             -- define z pointing on the array b[i]
    z[#z+1]=           -- insert into b[i] the result of the
       i+64==c:byte()  -- comparison of the current char, and the answer
  end
end)
return b
end

Essayer d'imprimer un tableau dans Lua entraînerait l'impression de son adresse et la concaténation des bools est impossible. Voici donc une fonction qui vous aidera si vous souhaitez tester cette soumission

function f(x)a={}b={}for i=1,#x do a[i]=x:sub(i,i)end table.sort(a)for i=1,a[#a]:byte()-64 do b[i]={}end x:gsub(".",function(c)for i=1,#b do z=b[i]z[#z+1]=i+64==c:byte()end end)return b end

function printBooleanMatrix(m)
  s="{"
  for i=1,#m
  do
    s=s.."{"
    for j=1,#m[i]
    do
      s=s..(m[i][j]and"1"or"0")..(j==#m[i]and""or",")
    end
    s=s.."}"..(i==#m and""or",\n")
  end
  print(s.."}")
end

printBooleanMatrix(f("ABBCCDDC"))

Perl, 84 octets

$\="\n";@i=split//,<>;pop@i;for$c('a'..(reverse sort@i)[0]){print map{/$c/?1:0}@i;}

Oh mon dieu, je semble avoir cassé le surligneur.

Version non golfée:

# output formatting
$\ = "\n";
# get input chars as array
@i = split //, <>;
# lose the newline
pop @i;
# iterate over characters up to the max
for $c ('a'..(reverse sort @i)[0]) {
    # print 1 for each match, 0 otherwise
    print map { /$c/ ? 1 : 0 } @i;
}

PHP, 106 92 90 87 octets

Utilise l'encodage Windows-1252.

for($x=A;$x++<=max($z=str_split($argv[1]));print~Ó)for(;$c=$z[+$$x++];)echo+(++$c==$x);

Courez comme ceci ( -dajouté pour l'esthétique uniquement):

php -d error_reporting=30709 -r 'for($x=A;$x++<=max($z=str_split($argv[1]));print~Ó)for(;$c=$z[+$$x++];)echo+(++$c==$x); echo"\n";' ABCDDHFHUYFSJGK

• Enregistré 14 octets en imbriquant les boucles dans l'autre sens
• Enregistré 2 octets en utilisant des variables variables pour éviter $i=0
• Enregistrement d'un octet en inversant la chaîne et en supprimant les délimiteurs de chaîne
• Enregistrement d'un octet en déplaçant l'écho (modifié en une impression pour s'adapter) à l'intérieur du premier pour la boucle et en supprimant les accolades
• Enregistrement d'un octet en incrémentant $xailleurs et en incrémentant $cpour compenser

C #, 68 octets

c=>Enumerable.Range(65,c.Max()-64).Select(x=>c.Select(y=>x==y?1:0));

Exécuter en C # Pad

Cette fonction anonyme prend une char[]entrée et une sortie IEnumerable<IEnumerable<int>>, avec seulement 0 et 1.

k, 15 octets

{x=/:65_!|/1+x}

Essayez-le en ligne!