Einführung

Hinweis: Dies ist keine Methode, um das Betrügen zu fördern. Wie Cᴏɴᴏʀ O'Bʀɪᴇɴ bereits sagte, ist das Lernen die beste Lösung, um einen Test zu bestehen: 3.

Betrachten Sie die folgenden Antworten auf den Multiple-Choice-Test:

ABCBCAAB

Hier ist eine Tabelle, die angibt, ob die Antworten übereinstimmen:

    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

Dies gibt uns die folgenden Zahlen:

10000110, 01010001, 00101000

Die Herausforderung besteht darin, diese Binärzahlen zu drucken. Es ist jedoch wichtig zu sehen, welche Buchstaben im Multiple-Choice-Test verwendet werden. Beispielsweise:

ABCDCDBCDABC

Dieser höchste Buchstabe ist Dder 4. Buchstabe des Alphabets . Daher müssen wir 4 verschiedene Binärzahlen ausgeben . Nämlich:

100000000100, 010000100010, 001010010001, 000101001000

Beachten Sie, dass Sie sich den höchsten Buchstaben ansehen müssen . Betrachten Sie das folgende Beispiel:

AACCACAC

Obwohl das Bnicht verwendet wird, müssen wir das binäre Ergebnis für ausgeben B. Das heißt, die Antwort wäre:

11001010, 00000000, 00110101

Aufgabe

Ausgehend von den Antworten auf einen Multiple-Choice-Test geben Sie die Binärzahlen aus. Sie können davon ausgehen, dass die Eingabe nicht leer ist und nur die Buchstaben enthält[A-Z] . Anstelle von Einsen und Nullen können Sie auch Wahr und Falsch verwenden.

Testfälle:

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

Das ist Code-Golf , also gewinnt die Einsendung mit der geringsten Anzahl von Bytes!

Pyth, 12 Bytes

mqLdzfsgRTzG

Ausgabe als verschachteltes Array von Booleschen Werten.

                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.

Probieren Sie es hier aus .

Python 3, 71

22 Bytes dank Ogaday gespart.
3 Bytes gespart dank DSM.

Eine Reihe von Bytes wurde gespeichert, da eine Reihe von Bools gültig ist.

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

Übernimmt die Eingabe in Großbuchstaben.

PowerShell, 95 94 73 Byte

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

Nimmt die Eingabe als Großbuchstaben, wandelt sie jedoch sofort um [char[]]. Wir durchlaufen dann eine Schleife von 0..bis zum Maximalwert von $aalphabetisch (daher die -65Konvertierung von ASCII). Zum Beispiel ADCEBkann dies als eine Schleife von Abis betrachtet werden E.

Bei jeder Iteration setzen wir eine Hilfsvariable $d, die dem aktuellen alphabetischen Wert (nicht ASCII) entspricht. Wir durchlaufen dann $ajedes Mal , wenn wir entweder 0oder 1in die Pipeline stellen, alle , je nachdem, ob $_-$d-65es sich um Wahrheit oder Falschheit handelt (dh ob wir uns im richtigen "Slot" befinden). Dies funktioniert, weil jeder Wert ungleich Null in PowerShell der Wahrheit entspricht. Das heißt, wenn unser aktueller Buchstabe $_nicht dem Slot "entspricht", in dem wir uns befinden $d, ist der !von $falseoder 0.

Jedes dieser Arrays von 0s und 1s wird dann -joinzusammengefügt und erneut in die Pipeline eingefügt. Wenn die äußere Schleife endet, haben wir ein Array von Zeichenfolgen, die eine Zeichenfolge pro Zeile drucken.

Beispiele

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 - speicherte ein Byte mit Boolean-not anstelle von -eq.
Edit 2 - speicherte weitere 21 Bytes durch Eliminieren des zusätzlichen Arrays $ b}

LabVIEW, 30 22 20 LabVIEW-Grundelemente

Geht von az durch, bis die Summe aller Bools gleich der Eingabelänge ist. Wandelt dann die Bools in Zahlen um.

Jetzt wird direkt das Maximum genommen, anstatt die Bool-Summe zu überprüfen.

Da 2D-Bools jetzt brauchbar sind, spare ich 2 Primitive, indem ich den grünen Draht davor ausgebe. Ich ?1:0könnte es wiederholen, bin aber zu faul ...

Cjam, 25 Bytes

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

Seufzer,

Erläuterung

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]

Anwendungsbeispiel: g "ACDC"-> [[True,False,False,False],[False,False,False,False],[False,True,False,True],[False,False,True,False]].

Wie es funktioniert:

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

Erläuterung:

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

Gibt ein 2D-Array von Bools aus

Probieren Sie es hier aus

ES6, 92 Bytes

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

Gibt ein Array von Arrays von Falschen und Wahrheiten zurück. Wenn Sie ein Array von Zeichenfolgen mit Nullen und Einsen bevorzugen, dann für 97 Bytes:

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

Oktave, 19 Bytes

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

Verwendet die automatische Übertragung von Octave über die Reichweite A bis zum Element max in der Eingabe, um ein boolesches 2D-Array übereinstimmender Elemente zu erstellen.

Beispiel:

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

Probieren Sie es hier auf ideone .

Lua, 208 189 Bytes

Das war in lua schwierig, wie immer müssen wir alles von Grund auf neu machen, und es nimmt viel Platz ein! Dieses Programm nimmt einen String als Argument und gibt das Ergebnis aus :).

Edit: @Adnan hat mir gesagt, dass wir jetzt eine Matrix von Booleschen Werten zurückgeben dürfen. Hier ist eine neue Version! Es ist jetzt eine Funktion, die eine Zeichenfolge mit Großbuchstaben verwendet und die Matrix zurückgibt :).

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

Alte 208 Byte Version

Dies ist diejenige, die mit Argumenten und Druckergebnissen arbeitet.

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 und Erklärungen

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

Der Versuch, ein Array in Lua zu drucken, würde dazu führen, dass dessen Adresse gedruckt wird und das Verketten von Bools nicht möglich ist. Hier ist eine Funktion, die Ihnen hilft, wenn Sie diese Einreichung testen möchten

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 je, ich habe anscheinend den Textmarker kaputt gemacht.

Ungolfed-Version:

# 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

Verwendet die Windows-1252-Codierung.

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

Laufen Sie wie folgt ( -dnur aus ästhetischen Gründen hinzugefügt):

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

• 14 Bytes gespart, indem die Schleifen umgekehrt geschachtelt wurden
• 2 Bytes durch Verwendung variabler Variablen gespart, um dies zu verhindern $i=0
• Ein Byte wurde durch Invertieren der Zeichenfolge und Löschen von Zeichenfolgenbegrenzern gespeichert
• Sie haben ein Byte gespeichert, indem Sie das Echo (in einen Ausdruck geändert, um es anzupassen) in die erste for-Schleife verschoben und geschweifte Klammern entfernt haben
• Ein Byte wurde durch Inkrementieren an einer $xanderen Stelle und Inkrementieren $czur Kompensation gespeichert

C #, 68 Bytes

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

Führen Sie in C # Pad

Diese anonyme Funktion nimmt ein char[]als Eingabe und gibt ein IEnumerable<IEnumerable<int>>mit nur Nullen und Einsen aus.

k, 15 Bytes

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

Probieren Sie es online!