Вступление

Примечание: это не какой-то метод поощрения мошенничества. Как уже сказал Cᴏɴᴏʀ O'Bʀɪᴇɴ , обучение - лучшее решение для прохождения теста: 3.

Рассмотрим следующие ответы на тест с множественным выбором:

ABCBCAAB

Вот таблица, которая указывает, совпадают ли ответы:

    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

Это дает нам следующие цифры:

10000110, 01010001, 00101000

Задача состоит в том, чтобы распечатать эти двоичные числа. Но важно видеть, какие буквы используются в тесте с множественным выбором. Например:

ABCDCDBCDABC

Это самая высокая буква является D, что является четвёртым буква в алфавите . Поэтому нам нужно вывести 4 разных двоичных числа. А именно:

100000000100, 010000100010, 001010010001, 000101001000

Обратите внимание, что вы должны смотреть на самую высокую букву . Рассмотрим следующий пример:

AACCACAC

Хотя значение Bне используется, нам нужно вывести двоичный результат для B. Это означает, что ответ будет:

11001010, 00000000, 00110101

задача

Учитывая ответы на тест с множественным выбором, выведите двоичные числа. Вы можете предположить, что ввод будет не пустым и будет содержать только буквы[A-Z] . Вместо единиц и нулей вы также можете использовать true и false.

Тестовые случаи:

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

Это код-гольф , поэтому выигрывает представление с наименьшим количеством байтов!

Pyth, 12 байт

mqLdzfsgRTzG

Выводится как вложенный массив логических значений.

                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.

Попробуй это здесь .

Python 3, 71

Сохранено 22 байта благодаря Ogaday.
Сохранено 3 байта благодаря DSM.

Сохранено несколько байтов благодаря действительному массиву bools.

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

Принимает ввод командной строки в верхнем регистре.

PowerShell, 95 94 73 байта

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

Принимает ввод в виде строки в верхнем регистре, но сразу же преобразует ее [char[]]. Затем мы возвращаемся 0..к максимальному значению, $aвзятому в алфавитном порядке (следовательно, -65для преобразования из ASCII). Например, с помощью ADCEB, это можно рассматривать как цикл от Aдо E.

На каждой итерации мы устанавливаем вспомогательную переменную, $dравную текущему алфавитному (не ASCII) значению. Затем цикл через все $a, каждый раз , когда ввод либо 0или 1на трубопроводе, в зависимости от того $_-$d-65является truthy или falsey (то есть ли мы в праве «слот»). Это работает, потому что любое ненулевое значение в PowerShell является правдивым, то есть если наша текущая буква $_не "равна" тому, в каком слоте мы находимся $d, то !это $falseили 0.

Каждый из этих массивов 0s и 1s затем -joinобъединяется и помещается в конвейер. Когда внешний цикл заканчивается, у нас есть массив строк, который будет печатать одну строку на строку.

Примеры

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

_{Редактировать 1 - сохранить байт, используя Boolean-not вместо -eq
Редактировать 2 - сохранить еще 21 байт, исключив дополнительный массив $ b}

LabVIEW, 30 22 20 Примитивы LabVIEW

Проходит от az до тех пор, пока сумма всех bools не станет равной длине ввода. затем преобразует bools в числа.

Теперь напрямую берется максимум вместо проверки суммы bool.

Так как 2D bools жизнеспособны, теперь я сохраняю 2 Примитива, выводя зеленый провод перед ним, ?1:0мог бы переделать его, но я слишком ленив ...

Cjam, 25 байтов

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

Вздох,

объяснение

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 байта

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

Пример использования: g "ACDC"-> [[True,False,False,False],[False,False,False,False],[False,True,False,True],[False,False,True,False]].

Как это устроено:

        <$>['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 байт

VhxGeSzmq@GNdz

Объяснение:

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

Выводит двумерный массив bools

Попробуй здесь

ES6, 92 байта

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

Возвращает массив массивов ложных и истинных значений. Если вы предпочитаете массив строк из нулей и единиц, то для 97 байтов:

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

Октава, 19 байт

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

Использует автоматическое вещание Octave по всему диапазону Aдо элемента max на входе, чтобы создать 2-мерный логический массив совпадающих элементов.

Пример:

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

Попробуйте это здесь на ideone .

Луа, 208 189 байт

Это было сложно в Луа, как обычно, мы должны делать все с нуля, и это занимает много места! Эта программа принимает строку в качестве аргумента и выводит результат :).

Изменить: @ Adnan сказал мне, что теперь мы можем вернуть матрицу логических значений, так что вот новая версия! Теперь это функция, которая принимает строку с заглавными буквами и возвращает матрицу :).

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

Старая версия 208 байт

Это тот, который работает с аргументом и печатать результаты.

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

Неуправляемый и объяснения

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

Попытка напечатать массив в Lua привела бы к печати его адреса, и объединение bools невозможно. Итак, вот функция, которая поможет вам, если вы хотите проверить это представление

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 байта

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

О, дорогая, я, кажется, сломал маркер.

Безголовая версия:

# 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 байт

Использует кодировку Windows-1252.

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

Запустите так ( -dдобавлено только для эстетики):

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 байтов за счет вложения циклов наоборот
• Сохранено 2 байта с помощью переменных переменных, чтобы предотвратить $i=0
• Сохранение байта путем инвертирования строки и удаления разделителей строк
• Сохраненный байт, перемещая эхо (измененное на печать, чтобы соответствовать) внутри первого для цикла и сбрасывая фигурные скобки
• Сохранял байт, увеличивая $xгде-то еще, и увеличивая, $cчтобы компенсировать

C #, 68 байт

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

Запустить в C # Pad

Эта анонимная функция принимает в char[]качестве входных данных и выводит IEnumerable<IEnumerable<int>>только 0 и 1.

к, 15 байт

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

Попробуйте онлайн!