Introducción

Nota: este no es un tipo de método para fomentar las trampas. Como ya dijo Cᴏɴᴏʀ O'Bʀɪᴇɴ , estudiar es la mejor solución para aprobar un examen: 3.

Considere las siguientes respuestas a la prueba de opción múltiple:

ABCBCAAB

Aquí hay una tabla que indica si las respuestas coinciden:

    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

Esto nos da los siguientes números:

10000110, 01010001, 00101000

El desafío es imprimir estos números binarios. Pero es importante ver qué letras se usan en la prueba de opción múltiple. Por ejemplo:

ABCDCDBCDABC

Esta letra más alta es D, que es la cuarta letra del alfabeto . Por lo tanto, necesitamos generar 4 números binarios diferentes . A saber:

100000000100, 010000100010, 001010010001, 000101001000

Tenga en cuenta que debe mirar la letra más alta . Considere el siguiente ejemplo:

AACCACAC

Aunque Bno se usa, necesitamos generar el resultado binario para B. Eso significa que la respuesta sería:

11001010, 00000000, 00110101

Tarea

Dadas las respuestas a una prueba de opción múltiple, genera los números binarios. Puede suponer que la entrada no estará vacía y solo contendrá las letras[A-Z] . En lugar de unos y ceros, también puede usar verdadero y falso.

Casos de prueba:

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

Este es el código de golf , por lo que gana el envío con la menor cantidad de bytes.

Pyth, 12 bytes

mqLdzfsgRTzG

Salidas como una matriz anidada 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.

Pruébalo aquí .

Pitón 3, 71

Guardado 22 bytes gracias a Ogaday.
Guardado 3 bytes gracias a DSM.

Ahorró un montón de bytes gracias a que una matriz de bools es válida.

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

Toma entrada de línea de comando en mayúscula.

PowerShell, 95 94 73 bytes

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

Toma la entrada como una cadena en mayúscula, pero la emite inmediatamente [char[]]. Luego pasamos 0..al valor máximo de $atomado alfabéticamente (de ahí la -65conversión de ASCII). Por ejemplo, con ADCEB, esto puede considerarse como un bucle de Aa E.

En cada iteración, establecemos una variable auxiliar $digual al valor alfabético actual (no ASCII). Luego hacemos un bucle a través de todo $a, cada vez que ponemos cualquiera 0o 1en la tubería, en función de si $_-$d-65es verdadero o falso (es decir, si estamos en el "espacio" correcto). Esto funciona porque cualquier valor distinto de cero en PowerShell es verdadero, lo que significa que si nuestra letra actual $_no es "igual" a la ranura en la que estamos $d, entonces !ese es $false, o 0.

Cada uno de estos conjuntos de 0s y 1S es entonces -joined juntos y volver a poner en la tubería. Cuando finaliza el bucle externo, tenemos una serie de cadenas, que imprimirán una cadena por línea.

Ejemplos

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

_{Edición 1: guardado un byte utilizando Boolean-not en lugar de -eq
Edición 2: guardado otros 21 bytes al eliminar la matriz adicional $ b}

LabVIEW, 30 22 20 Primitivas de LabVIEW

Pasa desde az hasta que la suma de todos los bools es igual a la longitud de entrada. luego transforma los bools en números.

Ahora toma directamente el máximo en lugar de verificar la suma de bool.

Dado que los bools 2D son viables ahora estoy ahorrando 2 primitivas al hacer salir el cable verde en frente de ?1:0podría rehacerlo, pero soy demasiado vago ...

Cjam, 25 bytes

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

Suspiro,

Explicación

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]

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

Cómo 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          

Pyth, 20 19 17 15 14 bytes

VhxGeSzmq@GNdz

Explicación:

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

Emite una matriz 2D de bools

Pruébalo aquí

ES6, 92 bytes

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

Devuelve una matriz de matrices de falsos y verdaderos. Si prefiere una matriz de cadenas de ceros y unos, entonces para 97 bytes:

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

Octava, 19 bytes

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

Utiliza la transmisión automática de Octave sobre el rango Aal elemento máximo en la entrada para producir una matriz booleana 2D de elementos coincidentes.

Ejemplo:

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

Pruébalo aquí en ideone .

Lua, 208 189 Bytes

Eso fue complicado en lua, como siempre, tenemos que hacer todo desde cero, ¡y ocupa mucho lugar! Este programa toma una cadena como argumento e imprime el resultado :).

Editar: @Adnan me dijo que ahora podemos devolver una matriz de booleanos, ¡así que aquí hay una nueva versión! Ahora es una función que toma una cadena de caracteres en mayúscula y devuelve la 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

Versión antigua de 208 bytes

Este es el que funciona con argumentos e imprimir 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,","))

Sin golfos y explicaciones

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

Intentar imprimir una matriz en Lua resultaría en imprimir su dirección y concatenar bools es imposible. Entonces, aquí hay una función que lo ayudará si desea probar esta presentación

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 querido, parece que he roto el marcador.

Versión sin golf:

# 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

Utiliza la codificación de Windows-1252.

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

Ejecutar así ( -dañadido solo 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

• Ahorró 14 bytes al anidar los bucles al revés
• Se guardaron 2 bytes mediante el uso de variables variables para evitar $i=0
• Guardado un byte invirtiendo cadena y soltando delimitadores de cadena
• Se guardó un byte moviendo el eco (cambiado a una impresión para que quepa) dentro del primer bucle y soltando llaves
• Guarde un byte incrementando $xen otro lugar e incrementándolo $cpara compensar

C #, 68 bytes

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

Ejecutar en C # Pad

Esta función anónima toma un char[]como entrada y emite un IEnumerable<IEnumerable<int>>, con solo 0 y 1.

k, 15 bytes

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

Pruébalo en línea!