Giới thiệu

Lưu ý: đây không phải là một số phương pháp để khuyến khích gian lận. Như Cᴏɴᴏʀ O'Bʀɪᴇɴ đã nói, học tập là giải pháp tốt nhất để vượt qua bài kiểm tra: 3.

Hãy xem xét các câu trả lời sau cho bài kiểm tra trắc nghiệm:

ABCBCAAB

Đây là bảng cho biết các câu trả lời có khớp hay không:

    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

Điều này cho chúng ta những con số sau:

10000110, 01010001, 00101000

Thách thức là in những số nhị phân này. Nhưng điều quan trọng là phải xem những chữ cái được sử dụng trong bài kiểm tra trắc nghiệm. Ví dụ:

ABCDCDBCDABC

Chữ cái cao nhất này Dlà chữ cái thứ 4 trong bảng chữ cái . Do đó, chúng ta cần xuất 4 số nhị phân khác nhau . Cụ thể là:

100000000100, 010000100010, 001010010001, 000101001000

Lưu ý rằng bạn phải nhìn vào chữ cái cao nhất . Hãy xem xét ví dụ sau:

AACCACAC

Mặc dù Bkhông được sử dụng, chúng ta cần xuất kết quả nhị phân cho B. Điều đó có nghĩa là, câu trả lời sẽ là:

11001010, 00000000, 00110101

Bài tập

Đưa ra các câu trả lời cho một bài kiểm tra trắc nghiệm, xuất ra các số nhị phân. Bạn có thể cho rằng đầu vào sẽ không trống và chỉ chứa các chữ cái[A-Z] . Thay vì những cái và số không, bạn cũng có thể sử dụng đúng và sai.

Các trường hợp thử nghiệm:

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

Đây là môn đánh gôn , vì vậy bài nộp có số byte ít nhất sẽ thắng!

Bình thường, 12 byte

mqLdzfsgRTzG

Đầu ra là một mảng booleans lồng nhau.

                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.

Hãy thử nó ở đây .

Con trăn 3, 71

Đã lưu 22 byte nhờ vào Ogaday.
Đã lưu 3 byte nhờ DSM.

Đã lưu một loạt các byte nhờ vào một loạt các bool là hợp lệ.

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

Đưa đầu vào dòng lệnh in hoa.

PowerShell, 95 94 73 byte

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

Lấy đầu vào dưới dạng một chuỗi chữ hoa, nhưng ngay lập tức ép nó [char[]]. Sau đó, chúng tôi lặp từ 0..giá trị tối đa của $abảng chữ cái (do đó -65để chuyển đổi từ ASCII). Ví dụ, với ADCEB, điều này có thể được coi là lặp từ Ađến E.

Mỗi lần lặp, chúng tôi đặt một biến trợ giúp $dbằng với giá trị bảng chữ cái hiện tại (không phải ASCII). Sau đó, chúng tôi lặp đi lặp lại tất cả $a, mỗi lần đặt một trong hai 0hoặc 1trên đường ống, dựa trên việc đó $_-$d-65là sự thật hay chim ưng (nghĩa là, liệu chúng tôi có ở đúng "khe" không). Điều này hoạt động bởi vì bất kỳ giá trị khác không nào trong PowerShell là trung thực, có nghĩa là nếu thư hiện tại của chúng tôi $_không "bằng" vị trí chúng tôi đang ở $d, thì đó !là $false, hoặc 0.

Mỗi mảng của 0s và 1s sau đó được -joinghép lại với nhau và đặt lại trên đường ống. Khi vòng lặp bên ngoài kết thúc, chúng ta có một chuỗi các chuỗi, sẽ in một chuỗi trên mỗi dòng.

Ví dụ

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

_{Chỉnh sửa 1 - đã lưu một byte bằng cách sử dụng Boolean-không thay vì -eq
Chỉnh sửa 2 - đã lưu 21 byte khác bằng cách loại bỏ mảng bổ sung $ b}

LabVIEW, 30 22 20 LabVIEW Nguyên thủy

Đi qua từ az cho đến khi tổng của tất cả các bool bằng với chiều dài đầu vào. sau đó biến đổi các bool thành số.

Bây giờ trực tiếp lấy max thay vì kiểm tra tổng bool.

Vì các bool 2D hiện khả thi nên tôi đang tiết kiệm 2 Nguyên thủy bằng cách xuất ra dây màu xanh lá cây phía trước ?1:0có thể làm lại nhưng tôi quá lười ...

Cjam, 25 byte

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

Thở dài,

Giải trình

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]

Ví dụ sử dụng: g "ACDC"-> [[True,False,False,False],[False,False,False,False],[False,True,False,True],[False,False,True,False]].

Làm thế nào nó hoạt động:

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

Giải trình:

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

Xuất ra một mảng 2D của bools

Hãy thử nó ở đây

ES6, 92 byte

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

Trả về một mảng các mảng giả và dấu. Nếu bạn thích một chuỗi các số 0 và một chuỗi, thì với 97 byte:

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

Octave, 19 byte

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

Sử dụng phát sóng tự động của Octave trên phạm vi Ađến phần tử tối đa trong đầu vào để tạo ra mảng boolean 2d của các phần tử phù hợp.

Thí dụ:

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

Hãy thử nó ở đây trên ideone .

Lua, 208 189 byte

Đó là khó khăn trong lua, như thường lệ, chúng tôi phải làm mọi thứ từ đầu, và nó mất rất nhiều chỗ! Chương trình này lấy một chuỗi làm đối số và in ra kết quả :).

Chỉnh sửa: @Adnan nói với tôi rằng chúng tôi hiện được phép trả lại một ma trận booleans, vì vậy đây là phiên bản mới! Bây giờ nó là một hàm lấy một chuỗi ký tự viết hoa và trả về ma trậ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

Phiên bản cũ 208 byte

Đây là một trong đó làm việc với các đối số và kết quả in.

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 và giải thích

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

Cố gắng in một mảng trong Lua sẽ dẫn đến việc in địa chỉ của nó và việc ghép các phân là không thể. Vì vậy, đây là một chức năng sẽ giúp bạn nếu bạn muốn kiểm tra trình này

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;}

Trời ơi, tôi dường như đã phá vỡ highllight.

Phiên bản bị đánh cắp:

# 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

Sử dụng mã hóa Windows-1252.

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

Chạy như thế này (chỉ -dthêm tính thẩm mỹ):

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

• Đã lưu 14 byte bằng cách lồng các vòng theo cách khác
• Đã lưu 2 byte bằng cách sử dụng các biến biến để ngăn chặn $i=0
• Đã lưu một byte bằng cách đảo ngược chuỗi và thả các dấu phân cách chuỗi
• Đã lưu một byte bằng cách di chuyển tiếng vang (đã thay đổi thành một bản in cho phù hợp) bên trong vòng lặp đầu tiên và bỏ dấu ngoặc nhọn
• Đã lưu một byte bằng cách tăng $xở một nơi khác và tăng $cđể bù

C #, 68 byte

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

Chạy trong C # Pad

Hàm ẩn danh này lấy char[]làm đầu vào và xuất ra một IEnumerable<IEnumerable<int>>, chỉ có 0 và 1.

k, 15 byte

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

Hãy thử trực tuyến!