introduzione

Nota: questo non è un metodo per incoraggiare gli imbrogli. Come già detto da C O'Bʀɪᴇɴ , studiare è la soluzione migliore per superare un test: 3.

Considera le seguenti risposte al test a scelta multipla:

ABCBCAAB

Ecco una tabella che indica se le risposte corrispondono:

    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

Questo ci dà i seguenti numeri:

10000110, 01010001, 00101000

La sfida è stampare questi numeri binari. Ma è importante vedere quali lettere vengono utilizzate nel test a scelta multipla. Per esempio:

ABCDCDBCDABC

Questa è la lettera più altaD , che è la quarta lettera dell'alfabeto . Pertanto, dobbiamo generare 4 diversi numeri binari. Vale a dire:

100000000100, 010000100010, 001010010001, 000101001000

Nota che devi guardare la lettera più alta . Considera il seguente esempio:

AACCACAC

Sebbene Bnon sia utilizzato, è necessario eseguire l'output del risultato binario per B. Ciò significa che la risposta sarebbe:

11001010, 00000000, 00110101

Compito

Date le risposte a un test a scelta multipla, genera i numeri binari. Si può presumere che l'input sarà non vuoto e che contenga solo le lettere[A-Z] . Invece di uno e zero, puoi anche usare vero e falso.

Casi 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

Questo è code-golf , quindi vince l'invio con il minor numero di byte!

Pyth, 12 byte

mqLdzfsgRTzG

Output come una matrice nidificata di booleani.

                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.

Provalo qui .

Python 3, 71

Risparmiato 22 byte grazie a Ogaday.
Salvato 3 byte grazie a DSM.

Ho salvato un sacco di byte grazie alla validità di un array di bool.

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

Accetta i caratteri maiuscoli dalla riga di comando.

PowerShell, 95 94 73 byte

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

Accetta l'input come una stringa maiuscola, ma la lancia immediatamente [char[]]. Passiamo quindi 0..al valore massimo di $apreso in ordine alfabetico (da qui il -65per convertire da ASCII). Ad esempio, con ADCEB, questo può essere pensato come un loop da Aa E.

Ad ogni iterazione, impostiamo una variabile helper $duguale all'attuale valore alfabetico (non ASCII). Passiamo quindi in rassegna tutto $a, ogni volta mettendo uno 0o 1sulla pipeline, in base alla $_-$d-65verità o alla falsità (ovvero, se siamo nella giusta "fessura"). Questo funziona perché qualsiasi valore diverso da zero in PowerShell è veritiero, il che significa che se la nostra lettera attuale $_non "eguaglia" lo slot in cui ci troviamo $d, allora lo !è $false, o 0.

Ognuno di quegli array di 0s e 1s viene quindi -joinassemblato e reinserito nella pipeline. Quando il ciclo esterno termina, abbiamo una matrice di stringhe, che stampa una stringa per riga.

Esempi

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

_{Modifica 1: salvato un byte utilizzando Boolean-not anziché -eq
Modifica 2: salvato altri 21 byte eliminando l'array aggiuntivo $ b}

LabVIEW, 30 22 20 LabVIEW Primitives

Passa da az fino a quando la somma di tutti i bool è uguale alla lunghezza di input. quindi trasforma i bool in numeri.

Ora prende direttamente il massimo invece di controllare la somma bool.

Dato che i bool 2D sono fattibili ora sto risparmiando 2 Primitive emettendo il filo verde davanti ?1:0potrebbe rifarlo ma sono troppo pigro ...

Cjam, 25 byte

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

Sospiro,

Spiegazione

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 byte

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

Esempio di utilizzo: g "ACDC"-> [[True,False,False,False],[False,False,False,False],[False,True,False,True],[False,False,True,False]].

Come funziona:

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

VhxGeSzmq@GNdz

Spiegazione:

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

Emette un array 2D di bool

Provalo qui

ES6, 92 byte

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

Restituisce una matrice di matrici di falsi e verità. Se si preferisce una matrice di stringhe di zeri e di uno, quindi per 97 byte:

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

Ottava, 19 byte

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

Utilizza la trasmissione automatica di Octave nell'intervallo Afino all'elemento massimo nell'input per produrre una matrice booleana 2d di elementi corrispondenti.

Esempio:

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

Provalo qui su ideone .

Lua, 208 189 byte

È stato complicato in lua, come al solito, dobbiamo fare tutto da zero e ci vuole molto posto! Questo programma accetta una stringa come argomento e stampa il risultato :).

Modifica: @Adnan mi ha detto che ora possiamo restituire una matrice di booleani, quindi eccone una nuova versione! Ora è una funzione che accetta una stringa di caratteri maiuscoli e restituisce 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

Vecchia versione di 208 byte

Questo è quello che funziona con argomenti e risultati di stampa.

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 spiegazioni

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

Cercare di stampare un array in Lua comporterebbe la stampa del suo indirizzo e la concatenazione di bool è impossibile. Quindi ecco una funzione che ti aiuterà se vuoi testare questo invio

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 byte

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

Oh caro, mi sembra di aver rotto l'evidenziatore.

Versione non golfata:

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

Utilizza la codifica Windows-1252.

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

Esegui in questo modo ( -daggiunto solo per l'estetica):

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

• Hai salvato 14 byte annidando i loop al contrario
• Salvato 2 byte utilizzando variabili variabili per impedire $i=0
• Salvataggio di un byte invertendo la stringa e rilasciando i delimitatori di stringa
• Salvataggio di un byte spostando l'eco (modificato in una stampa per adattarlo) all'interno del primo per loop e rilasciando parentesi graffe
• Ho salvato un byte incrementando $xaltrove e incrementando $cper compensare

C #, 68 byte

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

Esegui in C # Pad

Questa funzione anonima accetta un char[]input e genera un IEnumerable<IEnumerable<int>>, con solo 0 e 1.

k, 15 byte

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

Provalo online!