Introdução

Nota: este não é um tipo de método para incentivar a trapaça. Como Cᴏɴᴏʀ O'Bʀɪᴇɴ já disse, estudar é a melhor solução para passar no teste: 3.

Considere as seguintes respostas para o teste de múltipla escolha:

ABCBCAAB

Aqui está uma tabela que indica se as respostas correspondem:

    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

Isso nos dá os seguintes números:

10000110, 01010001, 00101000

O desafio é imprimir esses números binários. Mas é importante ver quais letras são usadas no teste de múltipla escolha. Por exemplo:

ABCDCDBCDABC

Esta carta mais alta é D, que é a quarta letra do alfabeto . Portanto, precisamos gerar 4 números binários diferentes . Nomeadamente:

100000000100, 010000100010, 001010010001, 000101001000

Observe que você precisa olhar para a letra mais alta . Considere o seguinte exemplo:

AACCACAC

Embora o Bnão seja usado, precisamos gerar o resultado binário para B. Isso significa que a resposta seria:

11001010, 00000000, 00110101

Tarefa

Dadas as respostas para um teste de múltipla escolha, produza os números binários. Você pode supor que a entrada não esteja vazia e contenha apenas as letras[A-Z] . Em vez de uns e zeros, você também pode usar verdadeiro e falso.

Casos de teste:

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

Isso é código-golfe , então a submissão com a menor quantidade de bytes ganha!

Pitão, 12 bytes

mqLdzfsgRTzG

Saídas como uma matriz aninhada de booleanos.

                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.

Experimente aqui .

Python 3, 71

Economizou 22 bytes graças a Ogaday.
Economizou 3 bytes graças ao DSM.

Salvei um monte de bytes, graças a uma matriz de bools sendo válida.

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

Toma entrada em linha de comando em maiúsculas.

PowerShell, 95 94 73 bytes

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

Recebe a entrada como uma sequência maiúscula, mas a lança imediatamente [char[]]. Em seguida, passamos 0..para o valor máximo de $atomadas em ordem alfabética (daí a -65conversão de ASCII). Por exemplo, com ADCEB, isso pode ser considerado um loop de Apara E.

A cada iteração, definimos uma variável auxiliar $digual ao valor alfabético atual (não ASCII). Em seguida, percorremos todos $a, cada vez que colocamos um 0ou 1no pipeline, com base em se $_-$d-65é verdade ou falsey (isto é, se estamos no "slot" certo). Isso funciona porque qualquer valor diferente de zero no PowerShell é verdadeiro, ou seja, se nossa letra atual $_não for "igual" em que slot estamos $d, o !que é $falseou é 0.

Cada uma dessas matrizes de 0s e 1s ent -joined em conjunto e re-colocada em pipeline. Quando o loop externo termina, temos uma matriz de strings, que imprimirá uma string por linha.

Exemplos

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 - salvou um byte usando Boolean-not em vez de -eq
Edit 2 - salvou outros 21 bytes ao eliminar a matriz extra $ b}

LabVIEW, 30 22 20 Primitivas do LabVIEW

Passa de az até que a soma de todos os bools seja igual ao comprimento da entrada. transforma os bools em números.

Agora pega diretamente o max em vez de verificar a soma booleana.

Como os bools 2D são viáveis, agora estou salvando 2 Primitivas emitindo o fio verde na frente do que ?1:0poderia refazê-lo, mas sou muito preguiçoso ...

Cjam, 25 bytes

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

Suspiro,

Explicação

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 bytes

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

Exemplo de uso: g "ACDC"-> [[True,False,False,False],[False,False,False,False],[False,True,False,True],[False,False,True,False]].

Como funciona:

        <$>['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          

Pitão, 20 19 17 15 14 bytes

VhxGeSzmq@GNdz

Explicação:

               - 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(^)

Gera uma matriz 2D de bools

Experimente aqui

ES6, 92 bytes

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

Retorna uma matriz de matrizes de falsas e verdadeiras. Se você preferir uma matriz de seqüências de zeros e uns, então para 97 bytes:

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

Oitava, 19 bytes

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

Utiliza a transmissão automática da Octave no intervalo Aaté o elemento max na entrada para produzir uma matriz booleana 2D de elementos correspondentes.

Exemplo:

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

Experimente aqui em ideone .

Lua, 208 189 Bytes

Isso foi complicado na lua, como sempre, temos que fazer tudo do zero, e isso leva muito tempo! Este programa pega uma string como argumento e imprime o resultado :).

Edit: @Adnan me disse que agora podemos retornar uma matriz de booleanos, então aqui está uma nova versão! Agora é uma função que pega uma sequência de caracteres em maiúsculas e retorna a matriz :).

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

Versão antiga de 208 bytes

É esse que trabalha com argumentos e imprime resultados.

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,","))

Ungolfed e explicações

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

Tentar imprimir uma matriz em Lua resultaria na impressão de seu endereço e a concatenação de bools é impossível. Então, aqui está uma função que irá ajudá-lo se você quiser testar este envio

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 bytes

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

Oh, querida, parece que eu quebrei o marcador.

Versão não destruída:

# 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 bytes

Usa a codificação Windows-1252.

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

Execute assim ( -dadicionado apenas para estética):

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

• Economizou 14 bytes aninhando os loops ao contrário
• 2 bytes salvos usando variáveis ​​variáveis ​​para evitar $i=0
• Salva um byte invertendo e excluindo delimitadores de string
• Salva um byte movendo o eco (alterado para uma impressão para caber) dentro do primeiro para loop e soltando chaves.
• Salvou um byte incrementando $xem outro lugar e incrementando $cpara compensar

C #, 68 bytes

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

Executar no C # Pad

Essa função anônima recebe a char[]como entrada e gera um IEnumerable<IEnumerable<int>>, com apenas 0 e 1.

k, 15 bytes

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

Experimente online!