Wprowadzenie

Uwaga: nie jest to jakaś metoda zachęcania do oszukiwania. Jak już powiedział Cᴏɴᴏʀ O'Bʀɪᴇɴ , studiowanie jest najlepszym rozwiązaniem do zdania testu: 3.

Rozważ następujące odpowiedzi na test wielokrotnego wyboru:

ABCBCAAB

Oto tabela wskazująca, czy odpowiedzi pasują do siebie:

    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

To daje nam następujące liczby:

10000110, 01010001, 00101000

Wyzwanie polega na wydrukowaniu tych liczb binarnych. Ważne jest jednak, aby zobaczyć, które litery są używane w teście wielokrotnego wyboru. Na przykład:

ABCDCDBCDABC

Ta najwyższa list to D, co jest 4-ty litera w alfabecie . Dlatego musimy wyprowadzić 4 różne liczby binarne. Mianowicie:

100000000100, 010000100010, 001010010001, 000101001000

Pamiętaj, że musisz spojrzeć na najwyższą literę . Rozważ następujący przykład:

AACCACAC

Chociaż Bnie jest używany, musimy podać wynik binarny dla B. Oznacza to, że odpowiedź brzmiałaby:

11001010, 00000000, 00110101

Zadanie

Biorąc pod uwagę odpowiedzi na test wielokrotnego wyboru, wypisz liczby binarne. Możesz założyć, że dane wejściowe będą niepuste i będą zawierać tylko litery[A-Z] . Zamiast zer i jedynek możesz również użyć wartości prawda i fałsz.

Przypadki testowe:

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

To jest golf golfowy , więc wygrywanie z najmniejszą ilością bajtów wygrywa!

Pyth, 12 bajtów

mqLdzfsgRTzG

Dane wyjściowe jako zagnieżdżona tablica wartości logicznych.

                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.

Wypróbuj tutaj .

Python 3, 71

Zaoszczędzono 22 bajty dzięki Ogaday.
Zaoszczędź 3 bajty dzięki DSM.

Zaoszczędzono sporo bajtów dzięki prawidłowej tablicy booli.

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

Pobiera duże linie poleceń.

PowerShell, 95 94 73 bajty

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

Pobiera dane wejściowe jako ciąg wielkich liter, ale natychmiast je rzuca [char[]]. Następnie zapętlamy od 0..maksymalnej wartości $apobranej alfabetycznie (stąd -65konwersja z ASCII). Na przykład za pomocą ADCEBmożna to traktować jako zapętlenie od Ado E.

W każdej iteracji ustawiamy zmienną pomocniczą $drówną bieżącej wartości alfabetycznej (nie ASCII). Następnie pętla przez wszystkie $a, za każdym razem albo oddanie 0lub 1na rurociągu, na podstawie tego, czy $_-$d-65jest truthy lub falsey (czyli czy jesteśmy w prawo „gniazdo”). To działa, ponieważ każda niezerowa wartość w PowerShell jest truthy, co oznacza, jeśli nasza obecna list $_nie „równe”, co jesteśmy w gniazdo $d, to !na to jest $false, albo 0.

Każdy z tych tablic 0S i 1S jest następnie -joined razem i ponownie wprowadzone do rurociągu. Kiedy pętla zewnętrzna się kończy, mamy tablicę ciągów, która wypisze jeden ciąg w linii.

Przykłady

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

_{Edycja 1 - zapisano bajt za pomocą logicznej nie-zamiast zamiastqq
Edycja 2 - zapisano kolejne 21 bajtów, eliminując dodatkową tablicę $ b}

LabVIEW, 30 22 20 LabVIEW Prymitywy

Przechodzi od az, aż suma wszystkich boolów będzie równa długości wejściowej. następnie Przekształca boole na liczby.

Teraz bezpośrednio bierze maksimum zamiast sprawdzania sumy bool.

Ponieważ boole 2D są opłacalne, teraz oszczędzam 2 prymitywy, wysyłając zielony drut przed nim, ?1:0aby go przerobić, ale jestem zbyt leniwy ...

Cjam, 25 bajtów

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

Westchnienie,

Wyjaśnienie

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 bajtów

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

Przykład użycia: g "ACDC"-> [[True,False,False,False],[False,False,False,False],[False,True,False,True],[False,False,True,False]].

Jak to działa:

        <$>['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 bajtów

VhxGeSzmq@GNdz

Wyjaśnienie:

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

Wysyła tablicę 2D booli

Wypróbuj tutaj

ES6, 92 bajty

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

Zwraca tablicę tablic fal i trues. Jeśli wolisz tablicę ciągów zer i jedynek, to dla 97 bajtów:

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

Oktawa, 19 bajtów

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

Wykorzystuje automatyczne nadawanie Octave w całym zakresie Ado maksymalnego elementu na wejściu, aby wygenerować 2d wartość logiczną pasujących elementów.

Przykład:

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

Wypróbuj tutaj na ideone .

Lua 208 189 bajtów

To było trudne w Lua, jak zwykle musimy wszystko robić od zera, a to zajmuje dużo miejsca! Ten program przyjmuje ciąg jako argument i wypisuje wynik :).

Edycja: @Adnan powiedział mi, że możemy teraz zwrócić matrycę wartości logicznych, więc oto nowa wersja! Jest to teraz funkcja, która pobiera ciąg wielkich liter i zwraca macierz :).

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

Stara wersja 208 bajtów

Ten działa z argumentami i wynikami drukowania.

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

Bez golfa i wyjaśnienia

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

Próba wydrukowania tablicy w Lua spowodowałaby wydrukowanie jej adresu i konkatenacja booli jest niemożliwa. Oto funkcja, która pomoże ci, jeśli chcesz przetestować to zgłoszenie

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 bajtów

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

Och, kochanie, chyba zepsułem zakreślacz.

Wersja bez golfa:

# 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 bajtów

Używa kodowania Windows-1252.

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

Działaj w ten sposób ( -ddodano tylko dla estetyki):

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

• Zaoszczędzono 14 bajtów, zagnieżdżając pętle na odwrót
• Zaoszczędzono 2 bajty, używając zmiennych zmiennych, aby zapobiec $i=0
• Zapisano bajt, odwracając ciąg i upuszczając ograniczniki ciągu
• Zapisano bajt, przenosząc echo (zmienione na druk w celu dopasowania) wewnątrz pierwszego dla pętli i upuszczając nawiasy klamrowe
• Zapisano bajt, zwiększając $xgdzie indziej i zwiększając w $ccelu skompensowania

C #, 68 bajtów

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

Uruchom w C # Pad

Ta anonimowa funkcja przyjmuje char[]jako dane wejściowe i wyjściowe an IEnumerable<IEnumerable<int>>, tylko z zerami i jedynkami.

k, 15 bajtów

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

Wypróbuj online!