एक से अधिक विकल्प परीक्षण तैयार करना

Question

परिचय

नोट: यह धोखा देने के लिए किसी प्रकार का तरीका नहीं है। जैसा कि C As 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 वां अक्षर है । इसलिए, हमें 4 अलग-अलग बाइनरी संख्याओं को आउटपुट करने की आवश्यकता है । अर्थात्:

100000000100, 010000100010, 001010010001, 000101001000

ध्यान दें कि आपको उच्चतम पत्र को देखना होगा । निम्नलिखित उदाहरण पर विचार करें:

AACCACAC

यद्यपि इसका Bउपयोग नहीं किया गया है, हमें बाइनरी परिणाम के लिए आउटपुट करने की आवश्यकता है B। इसका मतलब है, उत्तर होगा:

11001010, 00000000, 00110101

---

कार्य

एक बहु विकल्प परीक्षण के जवाबों को देखते हुए, बाइनरी संख्याओं का उत्पादन। आप मान सकते हैं कि इनपुट गैर-रिक्त होगा और केवल अक्षरों से युक्त होगा[A-Z] । अपने और शून्य के बजाय, आप सही और गलत का उपयोग भी कर सकते हैं।

---

परीक्षण के मामलों:

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

यह कोड-गोल्फ है , इसलिए कम से कम बाइट्स जीत के साथ सबमिशन!

Comments

क्या हम [a-z]इसके बजाय उपयोग कर सकते हैं ?

— FryAmTheEggman

@FryAmTheEggman of course :)

— अदनान

संबंधित

— अदनान

निर्दिष्ट आउटपुट के लिए कोई नियम नहीं है, क्या बूलों के 2 डी सरणी की अनुमति है?

— Eumel

ऐसा लगता है कि थोड़े अनुचित हैं, लेकिन मेरे लिए भी काम करता है ^ ^

— Eumel

Answer 1

पायथ, 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.

इसे यहाँ आज़माएँ ।

Answer 2

पायथन 3, 71

ओगाडे के लिए 22 बाइट्स का धन्यवाद दिया।
डीएसएम के लिए 3 बाइट्स को सहेजा गया।

बूलों के एक समूह को मान्य होने के लिए धन्यवाद बाइट्स का एक गुच्छा बचाया।

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

अपरकेस कमांड लाइन इनपुट लेता है।

Comments

विस्तारित*k,=map(ord,input())

— iterable

बूलों की एक सरणी अब भी संभव है, अगर यह मदद करता है।

— अदनान

Answer 3

पॉवरशेल, 95 94 73 बाइट्स

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

इनपुट को अपरकेस स्ट्रिंग के रूप में लेता है, लेकिन तुरंत इसे जमा देता है [char[]]। फिर हम वर्णानुक्रम में 0..लिए गए अधिकतम मान से लूप करते हैं $a(इसलिए -65ASCII से कन्वर्ट करने के लिए)। उदाहरण के लिए, इसके साथ ADCEB, के बारे में सोचा जा सकता Aहै E।

प्रत्येक पुनरावृत्ति, हम एक सहायक चर $dको वर्तमान वर्णमाला (ASCII नहीं) मान के बराबर सेट करते हैं । तब हम सभी के माध्यम से लूप करते हैं $a, हर बार 0या तो या 1पाइपलाइन पर, चाहे $_-$d-65सत्य या गलत हो (यानी, हम सही "स्लॉट" में हैं) के आधार पर। यह काम करता है क्योंकि PowerShell में कोई भी शून्य-शून्य मान सत्य नहीं है, जिसका अर्थ है कि यदि हमारा वर्तमान पत्र $_"बराबर" नहीं है $dतो हम किस स्लॉट में हैं , तो !वह है $false, या 0।

0एस और 1एस के उन सरणियों में से प्रत्येक को फिर -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 - बूलियन का उपयोग करके एक बाइट को बचाया नहीं -ईक्यू के बजाय
संपादित करें 2 - अतिरिक्त सरणी $ b को समाप्त करके एक और 21 बाइट बचाया}

Comments

बूलों की एक सरणी अब भी संभव है, अगर यह मदद करता है।

— अदनान

Answer 4

LabVIEW, 30 22 20 LabVIEW आदिम

एज़ से गुजरता है जब तक कि सभी बूल का योग इनपुट के बराबर नहीं होता। फिर संख्याओं के लिए ट्रांसफ़ॉर्म करता है।

अब सीधे बूल राशि की जाँच के बजाय अधिकतम लेता है।

चूंकि 2 डी बूल व्यवहार्य हैं, इसलिए अब हरे रंग के तार को सामने लाकर 2 प्राइमेटिव की बचत की ?1:0जा सकती है ताकि इसे फिर से बनाया जा सके लेकिन यह भी बहुत ...

Comments

बूलों की एक सरणी अब भी संभव है, अगर यह मदद करता है।

— अदनान

Answer 5

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

Comments

1k प्रतिनिधि BTW पर बधाई!

— ब्लू

बूलों की एक सरणी अब भी संभव है, अगर यह मदद करता है।

— अदनान

Answer 6

हास्केल, 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          

Answer 7

पायथ, 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(^)

एक 2 डी सरणी का उत्पादन करता है

इसे यहाँ आज़माएँ

Answer 8

ईएस 6, 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)

Answer 9

ऑक्टेव, 19 बाइट्स

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

Aमिलान तत्वों के 2d बूलियन सरणी का उत्पादन करने के लिए इनपुट में अधिकतम तत्व की सीमा तक ऑक्टेव के स्वचालित प्रसारण का उपयोग करता है ।

उदाहरण:

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

इसे इदोन पर यहां आजमाएं ।

Answer 10

लूआ, 208 189 बाइट्स

यह लुआ में मुश्किल था, हमेशा की तरह, हमें खरोंच से सब कुछ करना होगा, और यह बहुत जगह लेता है! यह प्रोग्राम तर्क के रूप में एक स्ट्रिंग लेता है, और परिणाम का प्रिंट आउट करता है :)।

संपादित करें: @ अदनान ने मुझे बताया कि हमें अब बूलियन का एक मैट्रिक्स वापस करने की अनुमति है, इसलिए यहां एक नया संस्करण है! यह अब एक फ़ंक्शन है जो कैपिटलाइज्ड वर्ण का एक स्ट्रिंग लेता है और मैट्रिक्स को वापस करता है :)।

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

लुआ में एक सरणी को प्रिंट करने की कोशिश करने से इसका पता प्रिंट हो जाएगा और बूल को जोड़ना असंभव है। तो यहाँ एक फ़ंक्शन है जो आपकी मदद करेगा यदि आप इस सबमिशन का परीक्षण करना चाहते हैं

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

Comments

बूलों की एक सरणी अब भी संभव है, अगर यह मदद करता है।

— अदनान

@ अच्छी तरह से, यह मुझे बहुत सारे बाइट्स छोड़ने की अनुमति देता है। मैं परीक्षण के उद्देश्य के लिए एक स्पष्ट उत्पादन करने के लिए एक समारोह लिख रहा हूं, फिर एक संशोधित संस्करण पोस्ट करें :)

— कैटेनिको

Answer 11

पर्ल, 84 बाइट्स

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

ओह प्रिय, मुझे लगता है कि हाइलाइटर टूट गया है।

Ungolfed संस्करण:

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

Answer 12

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क्षतिपूर्ति के लिए वेतन वृद्धि करके एक बाइट को बचाया

Answer 13

सी #, 68 बाइट्स

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

C # पैड में चलाएं

यह अनाम फ़ंक्शन char[]इनपुट के रूप में लेता है और IEnumerable<IEnumerable<int>>केवल 0 और 1 के साथ, एक आउटपुट देता है ।

Answer 14

k, 15 बाइट्स

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

इसे ऑनलाइन आज़माएं!