26

चीला (किताब से ड्रैगन अंडे रॉबर्ट एल फॉरवर्ड द्वारा) जीव है कि एक न्यूट्रॉन स्टार की सतह पर रहते हैं। उनका शरीर परिधि पर बारह आंखों के साथ सपाट और गोलाकार है, इसलिए वे स्वाभाविक रूप से बेस -12 नंबरिंग प्रणाली का उपयोग करते हैं।

चीला के बीच, युवा लोगों की देखभाल और शिक्षा की देखभाल पुराने लोगों द्वारा किए गए कार्य हैं। चूंकि युवा चीला को सिखाया जाता है कि कैसे गुणा करना है, इसलिए पुराने लोग गुणा तालिका का उपयोग कर सकते हैं।

आपका कार्य निम्नलिखित की तरह, बेस में 12x 12गुणन तालिका का उत्पादन करना है 12। अपरकेस अक्षर Aऔर Bदशमलव 10 और 11क्रमशः के अंकों के लिए उपयोग किया जाता है।

  1   2   3   4   5   6   7   8   9   A   B  10 
  2   4   6   8   A  10  12  14  16  18  1A  20 
  3   6   9  10  13  16  19  20  23  26  29  30 
  4   8  10  14  18  20  24  28  30  34  38  40 
  5   A  13  18  21  26  2B  34  39  42  47  50 
  6  10  16  20  26  30  36  40  46  50  56  60 
  7  12  19  24  2B  36  41  48  53  5A  65  70 
  8  14  20  28  34  40  48  54  60  68  74  80 
  9  16  23  30  39  46  53  60  69  76  83  90 
  A  18  26  34  42  50  5A  68  76  84  92  A0 
  B  1A  29  38  47  56  65  74  83  92  A1  B0 
 10  20  30  40  50  60  70  80  90  A0  B0 100

आउटपुट शॉ को स्क्रीन पर प्रिंट किया जाना चाहिए। प्रारूप निम्नानुसार होना चाहिए:

संख्या को प्रत्येक कॉलम के भीतर दाईं ओर संरेखित किया जाना चाहिए।
पहले स्तंभ से पहले रिक्त स्थान, अंतिम कॉलम के बाद रिक्त स्थान, या अंतिम पंक्ति के बाद एक अनुगामी नई पंक्ति।
स्तंभों के बीच पृथक्करण एक स्थान (जैसा कि ऊपर दिखाया गया है) या एक से अधिक स्थान हो सकता है, लेकिन स्तंभों के बीच रिक्त स्थान की संख्या लगातार होनी चाहिए। कॉलम पृथक्करण को मापने के लिए, विचार करें कि प्रदर्शित संख्याओं में कोई भी प्रमुख स्थान शामिल है जो आवश्यकता पूर्ति के लिए आवश्यक हो सकता है 1 (इसलिए प्रत्येक संख्या में तीन वर्ण होते हैं, जिनमें से पहला स्थान हो सकता है)। उदाहरण के लिए, दो-स्थान पृथक्करण वाली तालिका निम्नानुसार होगी:
```
  1    2    3    4    5    6    7    8    9    A    B   10 
  2    4    6    8    A   10   12   14   16   18   1A   20 
  3    6    9   10   13   16   19   20   23   26   29   30 
  4    8   10   14   18   20   24   28   30   34   38   40 
  5    A   13   18   21   26   2B   34   39   42   47   50 
  6   10   16   20   26   30   36   40   46   50   56   60 
  7   12   19   24   2B   36   41   48   53   5A   65   70 
  8   14   20   28   34   40   48   54   60   68   74   80 
  9   16   23   30   39   46   53   60   69   76   83   90 
  A   18   26   34   42   50   5A   68   76   84   92   A0 
  B   1A   29   38   47   56   65   74   83   92   A1   B0 
 10   20   30   40   50   60   70   80   90   A0   B0  100
```

एक न्यूट्रॉन स्टार पर कंप्यूटर का भंडारण वास्तव में महंगा है, इसलिए आपके कोड को यथासंभव कम बाइट्स का उपयोग करना चाहिए।

विस्तारित चुनौती और बोनस

आदर्श रूप से आपका कोड ब्रह्मांड के अन्य हिस्सों में पुन: उपयोग किया जाना चाहिए, जहां अन्य नंबरिंग सिस्टम उपयोग में हो सकते हैं। उस अंत तक, चुनौती वैकल्पिक रूप से निम्नानुसार है: आपका कोड Nइनपुट के रूप में एक संख्या को स्वीकार करता है और उपरोक्त प्रारूप के साथ बेस में एक Nएक्स Nगुणन तालिका उत्पन्न Nकरता है।

इनपुट कीबोर्ड से या फ़ंक्शन तर्क के रूप में हो सकता है। कार्यक्रम या समारोह के लिए काम करना चाहिए 2≤ N≤ 36पहले अंक के रूप में उपयोग करते हुए, Nअनुक्रम के पात्रों 0, 1, ..., 9, A, B, ..., Z(पत्र अपरकेस)

यह विस्तारित चुनौती वैकल्पिक है। यदि आप इस मार्ग का अनुसरण करते हैं, तो अपनी बाइट काउंट से 20% की छूट लें (पूर्णांक संख्या पर चक्कर लगाने की आवश्यकता नहीं है)।

— लुइस मेंडो
स्रोत

अच्छा एक लुइस! =) काश मैं एक MATLAB समाधान के साथ आने का समय था, लेकिन मैं क्रिसमस उपहार आयामों को मापने में व्यस्त हूं ...

— स्टीवी ग्रिफिन

6

उन गोलाकार टोपी के साथ गुड लक! :-P

— लुइस मेंडू

5

Because they have twelve eyes, they naturally use a base-12 numbering system.खैर, स्वाभाविक रूप से। यही कारण है कि हम बाइनरी का उपयोग करते हैं, ... ;-)

— टिम पेडरिक

2

@TimPederick अच्छा बिंदु: -D स्पष्ट करने के लिए: एक चीला का शरीर गोलाकार है, वे अंगों को आवश्यकतानुसार घुमा सकते हैं ... बारह आँखें होना संख्यात्मक रूप से उनके शरीर की सबसे विशिष्ट विशेषता है। मैंने सवाल अपडेट किया है, धन्यवाद!

— लुइस मेंडू

1

@LuisMendo बहुत अच्छा उपन्यास, जिसे आप उद्धृत करते हैं। Starquake भी बुरा नहीं है।

— lstefano

14

पायथ, 27 * 0.8 = 21.6

VSQsm.[\ 4jkXj*dNQrT99rG1SQ

इसे ऑनलाइन आज़माएँ: प्रदर्शन

स्पष्टीकरण:

VSQsm.[\ 4jkXj*dNQrT99rG1SQ   implicit: Q = input number
VSQ                           for N in [1, 2, ..., Q]:
    m                    SQ      map each number d in [1, 2, ..., Q] to:
              *dN                   N * d
             j   Q                  in base Q
            X     rT99rG1           replace the numbers [10, 11, ..., 98] with "A...Z"
          jk                        join to a string
     .[\ 4                          prepend spaces, so that the string has a length of 4
   s                             join all strings and print

— Jakube
स्रोत

11

सीजाम, 33 * 0.8 = 26.4 बाइट्स

ri:C,:)_ff{*Cb{_9>{'7+}&}%4Se[}N*

इसका परीक्षण यहां करें।

यह न्यूनतम आवश्यक पृथक्करण का उपयोग करता है।

व्याख्या

ri:C        e# Read input, convert to integer, store in C.
,:)         e# Get range [1 2 ... C].
_ff{        e# 2D-map over all repeated pairs from that range...
  *Cb       e#   Multiply, convert to base C.
  {         e#   Map over the digits...
    _9>     e#     Check if the digit is greater than 9.
    {'7+}&  e#     If so, add the digit to the character "7", to get "A" to "Z".
  }%
  4Se[      e#   Pad the digits with spaces from the left, to 4 elements.
}
N*          e# Join with linefeeds.

इनपुट के लिए तालिका 22(क्षैतिज स्क्रॉलबार के बिना पोस्ट में फिट होने वाली सबसे बड़ी):

   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F   G   H   I   J   K   L  10
   2   4   6   8   A   C   E   G   I   K  10  12  14  16  18  1A  1C  1E  1G  1I  1K  20
   3   6   9   C   F   I   L  12  15  18  1B  1E  1H  1K  21  24  27  2A  2D  2G  2J  30
   4   8   C   G   K  12  16  1A  1E  1I  20  24  28  2C  2G  2K  32  36  3A  3E  3I  40
   5   A   F   K  13  18  1D  1I  21  26  2B  2G  2L  34  39  3E  3J  42  47  4C  4H  50
   6   C   I  12  18  1E  1K  24  2A  2G  30  36  3C  3I  42  48  4E  4K  54  5A  5G  60
   7   E   L  16  1D  1K  25  2C  2J  34  3B  3I  43  4A  4H  52  59  5G  61  68  6F  70
   8   G  12  1A  1I  24  2C  2K  36  3E  40  48  4G  52  5A  5I  64  6C  6K  76  7E  80
   9   I  15  1E  21  2A  2J  36  3F  42  4B  4K  57  5G  63  6C  6L  78  7H  84  8D  90
   A   K  18  1I  26  2G  34  3E  42  4C  50  5A  5K  68  6I  76  7G  84  8E  92  9C  A0
   B  10  1B  20  2B  30  3B  40  4B  50  5B  60  6B  70  7B  80  8B  90  9B  A0  AB  B0
   C  12  1E  24  2G  36  3I  48  4K  5A  60  6C  72  7E  84  8G  96  9I  A8  AK  BA  C0
   D  14  1H  28  2L  3C  43  4G  57  5K  6B  72  7F  86  8J  9A  A1  AE  B5  BI  C9  D0
   E  16  1K  2C  34  3I  4A  52  5G  68  70  7E  86  8K  9C  A4  AI  BA  C2  CG  D8  E0
   F  18  21  2G  39  42  4H  5A  63  6I  7B  84  8J  9C  A5  AK  BD  C6  CL  DE  E7  F0
   G  1A  24  2K  3E  48  52  5I  6C  76  80  8G  9A  A4  AK  BE  C8  D2  DI  EC  F6  G0
   H  1C  27  32  3J  4E  59  64  6L  7G  8B  96  A1  AI  BD  C8  D3  DK  EF  FA  G5  H0
   I  1E  2A  36  42  4K  5G  6C  78  84  90  9I  AE  BA  C6  D2  DK  EG  FC  G8  H4  I0
   J  1G  2D  3A  47  54  61  6K  7H  8E  9B  A8  B5  C2  CL  DI  EF  FC  G9  H6  I3  J0
   K  1I  2G  3E  4C  5A  68  76  84  92  A0  AK  BI  CG  DE  EC  FA  G8  H6  I4  J2  K0
   L  1K  2J  3I  4H  5G  6F  7E  8D  9C  AB  BA  C9  D8  E7  F6  G5  H4  I3  J2  K1  L0
  10  20  30  40  50  60  70  80  90  A0  B0  C0  D0  E0  F0  G0  H0  I0  J0  K0  L0 100

— मार्टिन एंडर
स्रोत

8

MATL , 42 * .8 = 33.6

अस्वीकरण

चूंकि भाषा के निर्माता और चुनौती के लेखक एक ही हैं, यह जवाब जीतने के लिए योग्य नहीं है ।

यह प्रतिबंध आवश्यक है या नहीं, इस पर चर्चा के लिए, इस मेटा प्रश्न को देखें ।

कोड

iXK:t!*Y)KYAZ{'(?<=^0*)0'32cYXZc32hK4*[]e!

यह न्यूनतम पृथक्करण का उपयोग करता है।

उदाहरण

अष्ट गुणन सारणी

>> matl
 > iXK:t!*Y)KYAZ{'(?<=^0*)0'32cYXZc32chK4*[]e!
 > 
> 8
  1   2   3   4   5   6   7  10 
  2   4   6  10  12  14  16  20 
  3   6  11  14  17  22  25  30 
  4  10  14  20  24  30  34  40 
  5  12  17  24  31  36  43  50 
  6  14  22  30  36  44  52  60 
  7  16  25  34  43  52  61  70 
 10  20  30  40  50  60  70 100

व्याख्या

i              % input number, say n
XK             % copy to clipboard K
:              % vector 1, 2, ... n
t!*            % generate table: duplicate, transpose and multiply with broadcasting
Y)             % linearize into column array
KYA            % paste n from clipboard K. Convert to that base
Z{             % cell array of rows from array
'(?<=^0*)0'    % string literal for regexp replacement: find leading zeros
32c            % space character (for regexp replacement)
YX             % regexp replacement
Zc             % join cell array of strings into single string   
32             % code for space character. Conversion to char happens automatically
h              % concatenate horizontally
K4*[]e!        % paste n and multiply by 4. Reshape into 2D char array with 4*n columns

संपादित करें: इसे ऑनलाइन आज़माएं!

ऑनलाइन संकलक में चलाने के लिए, परिवर्तन (19 फ़रवरी, 2016 के रूप में) Y)करने के लिए X:, और निकालें []। यह उन परिवर्तनों के अनुकूल है जो इस चुनौती के बाद से भाषा में किए गए हैं।

— लुइस मेंडो
स्रोत

"चूंकि भाषा के निर्माता और चुनौती के लेखक एक ही हैं, यह जवाब जीतने के लिए योग्य नहीं है।" मुझे इस प्रतिबंध की जानकारी नहीं थी। क्या यह आत्म-लगाया गया है या आपको एक प्रासंगिक मेटा सर्वसम्मति मिली है?

— एलेक्स ए।

1

@AlexA। मैंने इसे स्वयं लगाया। मुझे संदेह था कि शायद इस बारे में किसी प्रकार का समझौता था। आपके स्मारक से मुझे लगता है कि वहाँ कोई नहीं है? मेरा कहना है: यदि आप एक भाषा डिज़ाइन करते हैं और फिर एक चुनौती देते हैं, तो आप शायद एक लाभप्रद स्थिति में हैं। आमतौर पर इसके बारे में क्या किया जाता है? कोई प्रतिबंध नहीं?

— लुइस मेंडू

मुझे लगता है कि जब तक आप विशेष रूप से अपनी भाषा में बिल्ट-इन के लिए उपयोग के मामले में चुनौती की योजना नहीं बनाते हैं, तब तक आप आवश्यक रूप से एक लाभ पर नहीं होंगे। मुझे इस तरह की किसी भी सहमति का पता नहीं है, इसलिए मैं मेटा पर पूछने की सलाह देता हूं।

— एलेक्स ए।

@AlexA। अच्छा विचार! हो गया

— लुइस मेंडू

@AlexA। यदि आपको ऐसा करने का मन करता है, तो हो सकता है कि आप अपने सुझाव को एक उत्तर के रूप में जोड़ दें?

— लुइस मेंडू

5

बैश + बीएसडी उपयोगिताओं, 36

echo Co{1..12}d{1..12}*p|dc|rs -j 12

OS X पर आउट-ऑफ-द-बॉक्स rsलिनक्स सिस्टम पर स्थापित करने की आवश्यकता हो सकती है।

बैश तक फैलता Co{1..12}d{1..12}*pहै Co1d1*p Co1d2*p Co1d3*p ... Co1d12*p ... Co12d12*p।
यह एक dcअभिव्यक्ति है जो आवश्यक शब्द उत्पन्न करता है। Coसेट आउटपुट बेस को 12. dएक स्थान के बजाय संख्याओं के बीच विभाजक के रूप में उपयोग किया जाता है, इसलिए ब्रेस विस्तार में कोई भी भागने की आवश्यकता नहीं है। dवास्तव में स्टैक के शीर्ष को डुप्लिकेट करता है, लेकिन इसे प्रभावी रूप से अनदेखा किया जाता है और त्याग दिया जाता है।
से आउटपुट dcसिंगल स्पेस-सेपरेटेड लाइन है। rsयह एक 12x12 सरणी में बदलता है। -jप्रत्येक शब्द को सही-सही बताता है।

— डिजिटल आघात
स्रोत

4

पायथ, 36 बाइट्स

Km+1dUJ12rjbmjkm.[\ 4j""m.Hbj*dkJKK1

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

— नीला
स्रोत

आप बदल सकते हैं Km+1dUJ12के साथ KSJ12। Sसीमा बनाता है [1, 2, ..., 12]। आप दोनों की जगह ले सकता j""है और jkसाथ s, अपने में शामिल होने के बाद से तार। और एक और बाइट: बदलें rjbm...K1करने के लिए jmr...1K। इस बदलाव के साथ आपको 28 बाइट्स KSJ12jmrsm.[\ 4sm.Hbj*dkJK1K

— मिलेंगे

4

पायथन, 153 147 132 बाइट्स * 0.8 = 105.6

def p(b):
 f=lambda n:(n>=b and f(n/b)or'')+chr((48,55)[n%b>9]+n%b)
 for i in range(b*b):print'%4s\n'[:3+(~i%b<1)]%f(~(i%b)*~(i/b)),

टिम पेडरिक की सलाह के लिए डाउन टू 132 बाइट्स! :)

— Basile-हेनरी
स्रोत

Upvoted, क्योंकि जितना अधिक मैं अपना जवाब गोल्फ , उतना ही यह आपकी तरह लग रहा है!

— टिम पैडरिक

कुछ संभावित सुधार: rjust( '%4s'%f(...)) के बजाय% -फॉर्म का उपयोग करें । देखें कि क्या print ...,(और फिर printन्यूलाइन के लिए एक ) के साथ प्रत्येक मान को प्रिंट करना इससे कम है join। यदि हां, तो छोरों को ढहने का प्रयास करें ।

— टिम पैडरिक 12

धन्यवाद टिम, मैंने छोरों को ढहाने की कोशिश की (मुझे यह चाल नहीं पता थी)। मुझे यकीन नहीं है कि यह मुझे कई बाइट्स देता है अगर कोई है लेकिन यह बहुत अच्छा है :)

— बेसाइल-हेनरी

मैं आपको फ़ंक्शन का उपयोग करते हुए एक टर्नरी फॉर्म (स्थिति andए orबी) के अंदर स्विच करता हूं । मैंने ऐसा तब तक किया जब तक मुझे एहसास नहीं हुआ कि मैं जो पहले था, उससे छोटा नहीं था, ... लेकिन आप पायथन 2 का उपयोग कर रहे हैं! आप के साथ एक बाइट बचा सकते हैं । fn>=bn//bn/b

— टिम पैडरिक

हाँ, यही कारण है कि मैंने आपके कोड के इस हिस्से का उपयोग अजगर 2 का शोषण करने के लिए एक और बाइट को बचाने के लिए किया :)

— बासी-मुर्गी

4

CJam, 38 33 32 38 * (.8) = 30.4 बाइट्स

qi:D,:):L{Lf*{Db{_9>{55+c}&}%4Se[}%N}%

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

(अब मार्टिन के समान दिखता है।)

qi:D,:):L          e# Generate list of [1...input]
{Lf*               e# Take each number in that list and multiply it by the same list ([[1,2,3,..,input][2,4,6,...,input],...})
{Db{_9>{55+c}&}%   e# Convert each product to base input. If a digit value is >= 10 add 55 and convert to char, to make it a letter.
4Se[}%N}%          e# Pad each number with spaces to length 4. Put a newline after each row.

— geokavel
स्रोत

3

पर्ल 6 , 60 बाइट्स -20% = 48 बाइट्स

{.put for (1..$_ X*1..$_)».base($_)».fmt('%3s').rotor($_)} # 60-20% = 48
#          ^-----------^ produce a list of two cross multiplied lists
#                        ^--------^ convert each to base N
#          format each to 3 spaces ^----------^
#         split the list into N element chunks ^--------^
#^-------^ print each of those on their own line with spaces between elements

(यह लगभग पूरी तरह से है कि मैं इसे कैसे लिखूंगा भले ही मैं इसे जितना छोटा हो सके उतना कम करने की कोशिश नहीं कर रहा था)

उपयोग:

{...}(2)
  1  10
 10 100

my &code = {...}
code 2;
  1  10
 10 100

{...}(12);
  1   2   3   4   5   6   7   8   9   A   B  10
  2   4   6   8   A  10  12  14  16  18  1A  20
  3   6   9  10  13  16  19  20  23  26  29  30
  4   8  10  14  18  20  24  28  30  34  38  40
  5   A  13  18  21  26  2B  34  39  42  47  50
  6  10  16  20  26  30  36  40  46  50  56  60
  7  12  19  24  2B  36  41  48  53  5A  65  70
  8  14  20  28  34  40  48  54  60  68  74  80
  9  16  23  30  39  46  53  60  69  76  83  90
  A  18  26  34  42  50  5A  68  76  84  92  A0
  B  1A  29  38  47  56  65  74  83  92  A1  B0
 10  20  30  40  50  60  70  80  90  A0  B0 100

{...}(18);
  1   2   3   4   5   6   7   8   9   A   B   C   D   E   F   G   H  10
  2   4   6   8   A   C   E   G  10  12  14  16  18  1A  1C  1E  1G  20
  3   6   9   C   F  10  13  16  19  1C  1F  20  23  26  29  2C  2F  30
  4   8   C   G  12  16  1A  1E  20  24  28  2C  2G  32  36  3A  3E  40
  5   A   F  12  17  1C  1H  24  29  2E  31  36  3B  3G  43  48  4D  50
  6   C  10  16  1C  20  26  2C  30  36  3C  40  46  4C  50  56  5C  60
  7   E  13  1A  1H  26  2D  32  39  3G  45  4C  51  58  5F  64  6B  70
  8   G  16  1E  24  2C  32  3A  40  48  4G  56  5E  64  6C  72  7A  80
  9  10  19  20  29  30  39  40  49  50  59  60  69  70  79  80  89  90
  A  12  1C  24  2E  36  3G  48  50  5A  62  6C  74  7E  86  8G  98  A0
  B  14  1F  28  31  3C  45  4G  59  62  6D  76  7H  8A  93  9E  A7  B0
  C  16  20  2C  36  40  4C  56  60  6C  76  80  8C  96  A0  AC  B6  C0
  D  18  23  2G  3B  46  51  5E  69  74  7H  8C  97  A2  AF  BA  C5  D0
  E  1A  26  32  3G  4C  58  64  70  7E  8A  96  A2  AG  BC  C8  D4  E0
  F  1C  29  36  43  50  5F  6C  79  86  93  A0  AF  BC  C9  D6  E3  F0
  G  1E  2C  3A  48  56  64  72  80  8G  9E  AC  BA  C8  D6  E4  F2  G0
  H  1G  2F  3E  4D  5C  6B  7A  89  98  A7  B6  C5  D4  E3  F2  G1  H0
 10  20  30  40  50  60  70  80  90  A0  B0  C0  D0  E0  F0  G0  H0 100

— ब्रैड गिल्बर्ट b2gills
स्रोत

एक विशेषज्ञ नहीं, लेकिन 'के लिए' और '(' की आवश्यकता के बीच की जगह है? जहां संभव हो वहाँ रिक्त स्थान क्लिप चाहिए।

— J_F_B_M

@J_F_B_M मैं हमेशा पहले रिक्त स्थान निकालने का प्रयास करता हूं। इसलिए यदि कोई स्थान है तो इसकी आवश्यकता है। अगर मैंने यह सुनिश्चित करने के लिए जगह को हटा दिया, तो यह भी संकलित नहीं होगा क्योंकि यह संशोधक लूप निर्माण के बजाय for(एक सबरूटीन नाम के कॉल की शुरुआत के रूप में माना जाएगा । जो एक संकलन त्रुटि का कारण होगा। forfor

— ब्रैड गिल्बर्ट b2gills

कुछ सीखा। धन्यवाद।

— J_F_B_M

3

जावास्क्रिप्ट (ईएस 6) 84 (105-20%)

स्पष्ट तरीका, के साथ शुरू करने के लिए।

n=>{for(o=i=``;i++<n;o+=`
`)for(j=0;j++<n;)o+=(`   `+(i*j).toString(n)).slice(-4).toUpperCase();alert(o)}

टिप्पणियाँ

यह एक लोअर जेएस हैस्ट्रिंग लोअरकेस अक्षरों का उत्पादन
alert तालिका को आउटपुट करने का सबसे अच्छा तरीका नहीं है, लेकिन यह छोटा है, क्योंकि "स्क्रीन पर प्रदर्शित" करने के लिए एक स्पष्ट अनुरोध है
बस मान लौटाने से एक युगल बाइट कम होगी।

कम गोल्फ वाला

n=>{
  for(o='', i=0; i++<n; o+='\n')
    for(j=0;j++<n;)
       o+=('   '+(i*j).toString(n)).slice(-4).toUpperCase()
  alert(o)
}

— edc65
स्रोत

3

पायथन 3, 126 - 20% = 100.8 बाइट्स

बाहरी कार्य, tवह है जो वास्तव में गुणा तालिका प्रिंट करता है। आंतरिक कार्य, iसंख्या का रूपांतरण आधार से 2 से 36 तक करता है।

def t(b):
 i=lambda n:(n>=b and i(n//b)or'')+chr(n%b+[48,55][n%b>9]);R=range(b)
 for r in R:print(*('%3s'%i(~r*~c)for c in R))

उनके समाधान के लिए बुमेरांग और एक गोल्फ टिप के लिए टोपी टिप। मैं बूमरैंग के समाधान से कुछ भी कॉपी करने से बचता था, लेकिन मैंने खुद को इस पर नज़र रखने की अनुमति दी कि मैं और अधिक कहां ट्रिम कर सकता हूं। और इससे पहले भी, मैंने पाया कि जितना अधिक मैंने इसे गोल्फ दिया, उतना ही मेरा बूमरैंग जैसा दिखने लगा!

— टिम पेडरिक
स्रोत

अच्छा समाधान! :) और आप मुझसे बेहतर स्कोर प्राप्त कर सकते हैं! मुझे अपने <10 के बजाय> 9 पसंद है। मैं python3 और तारांकित अभिव्यक्तियों से परिचित नहीं हूं (मुझे यह देखना था)। मुझे आपकी ~ ट्रिक बहुत पसंद है, मुझे उसका उपयोग शुरू करने की आवश्यकता है!

— बेसाइल-हेनरी

मैंने आपके समाधान का थोड़ा परीक्षण किया और ऐसा लग रहा है कि मैं दो से अधिक आधार n अंक वापस नहीं करता हूं। उदाहरण के लिए यदि आप इसके बजाय print(i(15,12),i(120,12),i(144,12),i(150,12))अपना कोड रिटर्न 13 A0 00 06करते हैं 13 A0 100 106। दुर्भाग्य से कार्य को एक 3 अंकों का आधार n नंबर (100) प्रिंट करना होता है। इसे ठीक करना बहुत मुश्किल नहीं है, लेकिन इसमें कुछ बाइट्स भी शामिल हो सकते हैं ...

— basile-henry

@ बूमरंग: <खरोंच सिर> मुझे लगता है कि मुझे कुछ टूट गया होगा, फिर ... क्योंकि यह पहले काम कर रहा था ! यह प्रतीत होता है कि यह एक अग्रणी 1 नहीं देगा ... ओह, रुको, मुझे पता है कि समस्या क्या है। यह होना चाहिए n>=b, नहीं n>b।

— टिम पैडरिक

मुझे कोड को छोटा बनाने के लिए एक और चाल मिली: i को t (b) में परिभाषित करें ताकि आप i में दूसरा तर्क निकाल सकें! इस तरह:

def t(b):  i=lambda n:(n>=b and i(n//b)or'')+chr(n%b+[48,55][n%b>9])  R=range(b)  for r in R:print(*('%3s'%i(~r*~c)for c in R))

मैं अपने समाधान में ऐसा करना चाहता हूं, लेकिन अब हमारे दोनों समाधान काफी करीब हैं, साथ ही बेहतर हो सकता है ^ ^

— बेसाइल-हेनरी

@ बूमरंग: अरे, आपका पहला था, और मुझे लगता है कि पायथन 2 पर्याप्त शॉर्टकट प्रदान करता है जो आप अभी भी मुझसे आगे निकल सकते हैं। लेकिन मदद के लिए धन्यवाद!

— टिम पैडरिक

3

जावास्क्रिप्ट (ES6) 96.8 93.6 बाइट्स (117 का 20%)

n=>{b='';for(i=0;i++<n;b+=`\n`)for(j=0;j++<n;)a=(i*j).toString(n).toUpperCase(),b+=' '.repeat(4-a.length)+a;alert(b)}

व्याख्या

n=>
    {                                     
      b='';                                    //clear table var at each run
      for(i=0;i++<n;b+=`\n`)                   //iterate through rows
        for(j=0;j++<n;)                        //iterate through cols
          a=(i*j).toString(n).toUpperCase(),   //get desired number
          b+=' '.repeat(4-a.length)+a";        //pad to right
    alert(b)                                   //display result
}

- @ edc65 की बदौलत 4 बाइट्स बचाए

— Aᴄʜᴇʀᴏɴғᴀɪʟ
स्रोत

1

बस {} का उपयोग करना और alert(b)कोई evalछोटा नहीं है। और कम से कम, चर से बचें a, यह बेकार हैb+=' '.repeat(4-a.length)+(i*j).toString(n).toUpperCase()

— edc65

धन्यवाद for मुझे अपने लिए इसे प्रदर्शित करने की आवश्यकता नहीं दिखाई दी () मूल रूप से मान लौटाने की तुलना में कम था। @ edc65 हालांकि, अगर मैं इससे बचता हूं aतो आप कैसे गणना करते हैं ...repeat(4-a.length)...?

— a '22

ऊह माफ करना आप एक के बारे में सही हो। +1 इस प्रकार है

— edc65

2

MATLAB, 111 * 0.8 = 88.8 110 * 0.8 = 88 बाइट्स

मेरी पहली फिल्म यहां है:

@(N)disp(reshape(strrep(strrep([' ',strjoin(cellstr(dec2base([1:N]'*[1:N],N)))],' 0','  '),' 0','  '),4*N,N)')

स्पष्टीकरण:

[1:N]'*[1:N] बेस 10 में गुणा तालिका बनाएं

dec2base([1:N]'*[1:N],N) बेस में परिवर्तित करें। आउटपुट 0-s अग्रणी के साथ चार सरणी है

strjoin(cellstr(dec2base(___))) अंतरिक्ष में 1x575 स्ट्रिंग पैदावार के साथ सेल और बैक टू चारिंग ज्वाइनिंग स्ट्रिंग्स

[' ',strjoin(___)] 576 तत्वों के लिए अंतरिक्ष में भाग लें

strrep(___,' 0',' ')एक अग्रणी शून्य निकालें। हम इसे दो बार करते हैं क्योंकि हमारे पास दो प्रमुख शून्य के साथ तार हैं

reshape(___,4*N,N)' 1x576 चार सरणी को 48x12 चार सरणी में परिवर्तित करें

disp(___) बिना परिणाम प्रदर्शित करें ans =

आउटपुट:

 1   2   3   4   5   6   7   8   9   A   B  10
 2   4   6   8   A  10  12  14  16  18  1A  20
 3   6   9  10  13  16  19  20  23  26  29  30
 4   8  10  14  18  20  24  28  30  34  38  40
 5   A  13  18  21  26  2B  34  39  42  47  50
 6  10  16  20  26  30  36  40  46  50  56  60
 7  12  19  24  2B  36  41  48  53  5A  65  70
 8  14  20  28  34  40  48  54  60  68  74  80
 9  16  23  30  39  46  53  60  69  76  83  90
 A  18  26  34  42  50  5A  68  76  84  92  A0
 B  1A  29  38  47  56  65  74  83  92  A1  B0
10  20  30  40  50  60  70  80  90  A0  B0 100

यदि हम स्टेटमेंट नहीं गिनते हैं N=12;, तो 5*.8=4बाइट्स बच जाते हैं। इसके अलावा, यदि ans =आउटपुट को सहन किया जाता है, तो हम disp()एक और 6*0.8=4.8बाइट्स को बचा सकते हैं । बेशक, बाइट्स को बचाने के अन्य तरीके हो सकते हैं :)

— brainkz
स्रोत

सामान्य तौर पर, ansआउटपुट को एक फ़ंक्शन तर्क होने पर सहन किया जाता है। लेकिन इस मामले में चुनौती कहती है "आउटपुट को स्क्रीन पर मुद्रित किया जाना चाहिए", इसलिए ansअनुमति नहीं है। साथ ही, Nविस्तारित चुनौती में इनपुट के रूप में लिया जाना चाहिए। आप एक अनाम फ़ंक्शन का उपयोग करके इसे हल कर सकते हैं: @(n)disp(reshape(strrep(strrep([' ',strjoin(cellstr(dec2base([1:N]'*[1:N],N)))],' 0',' '),' 0',' '),4*N,N)')जिसे आप का उपयोग करके कॉल करेंगेans(12)

— लुइस मेंडो

1

ओह और साइट पर आपका स्वागत है! :-)

— लुइस मेंडू

@LuisMendo धन्यवाद! मैं अपने उत्तर को @ (N) संकेतन के साथ संपादित करूंगा

— brainkz

2

पायथन 3: 166 161 152 - 20% = 121.6 बाइट्स

मुझे पता है कि यह मौजूदा पायथन जवाबों से हीन है, लेकिन मुझे लगा कि यह एक शॉट है। यह मेरी पहली बार इस साइट पर पोस्टिंग है ...

def t(b):
 r=range(1,b+1);f=lambda x:x and f(x//b)+chr((55,48)[x%b>9]+x%b)or''
 print('\n'.join(''.join(B)for B in(('%4s'%f(i*j)for j in r)for i in r)))

— तैमू पिप्पो
स्रोत

रिक्त स्थान के बाद 3 समापन कोष्ठक और 2 संख्यात्मक शाब्दिक हैं। वे रिक्त स्थान अनावश्यक हैं। अन्यथा अच्छा पहले प्रयास करें। BTW, पायथन में गोल्फ के लिए युक्तियाँ एक अच्छा पढ़ने है।

— मैनटवर्क

PPCG.SE में आपका स्वागत है, भले ही यह अन्य पायथन उत्तर को हरा नहीं देता है, जब तक कि यह अलग नहीं है (एक ही अल्गोरिथम / विचार नहीं), आप इसे पोस्ट कर सकते हैं :)।

— कटेन्को

@manatwork धन्यवाद! मुझे उस के साथ एक और 9 बाइट्स मिलीं।

— तैमू पिप्पो

2

एपीएल, 32 31 × 0.8 = 24.8 बाइट्स

{¯4↑¨⊃∘(⎕D,⎕A)¨¨⍵⊥⍣¯1¨∘.×⍨1+⍳⍵}

मूल में 0. अंग्रेजी में:

∘.×⍨1+⍳⍵: पहाड़ा
⍵⊥⍣¯1¨: बेस में व्यक्त express गुणन तालिका के प्रत्येक तत्व
⊃∘(⎕D,⎕A)¨¨: वर्णों के वेक्टर की तालिका में संख्याओं के वेक्टर की तालिका में परिवर्तित करें
¯4↑¨: परिणाम के प्रत्येक तत्व की लंबाई 4 के लिए सही संरेखित करें

डिफ़ॉल्ट APL प्रिंट रूटीन सही काम करता है।

      {¯4↑¨(⍵⊥⍣¯1¨∘.×⍨1+⍳⍵)⊃¨¨⊂⊂⎕D,⎕A}13
    1     2     3     4     5     6     7     8     9     A     B     C    10 
    2     4     6     8     A     C    11    13    15    17    19    1B    20 
    3     6     9     C    12    15    18    1B    21    24    27    2A    30 
    4     8     C    13    17    1B    22    26    2A    31    35    39    40 
    5     A    12    17    1C    24    29    31    36    3B    43    48    50 
    6     C    15    1B    24    2A    33    39    42    48    51    57    60 
    7    11    18    22    29    33    3A    44    4B    55    5C    66    70 
    8    13    1B    26    31    39    44    4C    57    62    6A    75    80 
    9    15    21    2A    36    42    4B    57    63    6C    78    84    90 
    A    17    24    31    3B    48    55    62    6C    79    86    93    A0 
    B    19    27    35    43    51    5C    6A    78    86    94    A2    B0 
    C    1B    2A    39    48    57    66    75    84    93    A2    B1    C0 
   10    20    30    40    50    60    70    80    90    A0    B0    C0   100

— lstefano
स्रोत

-1:{¯4↑¨⊃∘(⎕D,⎕A)¨¨⍵⊥⍣¯1¨∘.×⍨1+⍳⍵}

— अदाम

"वर्ण" के बजाय आपको "बाइट्स" का उपयोग करना चाहिए एक लिंक के साथ meta.codegolf.stackexchange.com/a/9429/43319 ।

— अदम

1

रूबी, 69 66 अक्षर - 20% = 52.8

->n{(r=1..n).map{|a|puts r.map{|b|"%4s"%(a*b).to_s(n).upcase}*''}}

नमूना रन:

2.1.5 :001 > ->n{(r=1..n).map{|a|puts r.map{|b|"%4s"%(a*b).to_s(n).upcase}*''}}[4]
   1   2   3  10
   2  10  12  20
   3  12  21  30
  10  20  30 100

— आदमी काम पर है
स्रोत

1

ksh93, 51 * 0.8 == 40.8 बाइट्स

eval echo "'
' {"{1..$1}'..$((++n*$1))..$n%3..$1d}'

यह बेस 64 (ksh द्वारा समर्थित सबसे बड़ा मूलांक) तक काम करना चाहिए। उदाहरण:

 $ n= ksh -s 12 <<\EOF
eval echo "'
' {"{1..$1}'..$((++n*$1))..$n%3..$1d}'
EOF


   1   2   3   4   5   6   7   8   9   a   b  10
   2   4   6   8   a  10  12  14  16  18  1a  20
   3   6   9  10  13  16  19  20  23  26  29  30
   4   8  10  14  18  20  24  28  30  34  38  40
   5   a  13  18  21  26  2b  34  39  42  47  50
   6  10  16  20  26  30  36  40  46  50  56  60
   7  12  19  24  2b  36  41  48  53  5a  65  70
   8  14  20  28  34  40  48  54  60  68  74  80
   9  16  23  30  39  46  53  60  69  76  83  90
   a  18  26  34  42  50  5a  68  76  84  92  a0
   b  1a  29  38  47  56  65  74  83  92  a1  b0
  10  20  30  40  50  60  70  80  90  a0  b0 100

 $ n= ksh -s 22 <<\EOF
eval echo "'
' {"{1..$1}'..$((++n*$1))..$n%3..$1d}'
EOF


   1   2   3   4   5   6   7   8   9   a   b   c   d   e   f   g   h   i   j   k   l  10
   2   4   6   8   a   c   e   g   i   k  10  12  14  16  18  1a  1c  1e  1g  1i  1k  20
   3   6   9   c   f   i   l  12  15  18  1b  1e  1h  1k  21  24  27  2a  2d  2g  2j  30
   4   8   c   g   k  12  16  1a  1e  1i  20  24  28  2c  2g  2k  32  36  3a  3e  3i  40
   5   a   f   k  13  18  1d  1i  21  26  2b  2g  2l  34  39  3e  3j  42  47  4c  4h  50
   6   c   i  12  18  1e  1k  24  2a  2g  30  36  3c  3i  42  48  4e  4k  54  5a  5g  60
   7   e   l  16  1d  1k  25  2c  2j  34  3b  3i  43  4a  4h  52  59  5g  61  68  6f  70
   8   g  12  1a  1i  24  2c  2k  36  3e  40  48  4g  52  5a  5i  64  6c  6k  76  7e  80
   9   i  15  1e  21  2a  2j  36  3f  42  4b  4k  57  5g  63  6c  6l  78  7h  84  8d  90
   a   k  18  1i  26  2g  34  3e  42  4c  50  5a  5k  68  6i  76  7g  84  8e  92  9c  a0
   b  10  1b  20  2b  30  3b  40  4b  50  5b  60  6b  70  7b  80  8b  90  9b  a0  ab  b0
   c  12  1e  24  2g  36  3i  48  4k  5a  60  6c  72  7e  84  8g  96  9i  a8  ak  ba  c0
   d  14  1h  28  2l  3c  43  4g  57  5k  6b  72  7f  86  8j  9a  a1  ae  b5  bi  c9  d0
   e  16  1k  2c  34  3i  4a  52  5g  68  70  7e  86  8k  9c  a4  ai  ba  c2  cg  d8  e0
   f  18  21  2g  39  42  4h  5a  63  6i  7b  84  8j  9c  a5  ak  bd  c6  cl  de  e7  f0
   g  1a  24  2k  3e  48  52  5i  6c  76  80  8g  9a  a4  ak  be  c8  d2  di  ec  f6  g0
   h  1c  27  32  3j  4e  59  64  6l  7g  8b  96  a1  ai  bd  c8  d3  dk  ef  fa  g5  h0
   i  1e  2a  36  42  4k  5g  6c  78  84  90  9i  ae  ba  c6  d2  dk  eg  fc  g8  h4  i0
   j  1g  2d  3a  47  54  61  6k  7h  8e  9b  a8  b5  c2  cl  di  ef  fc  g9  h6  i3  j0
   k  1i  2g  3e  4c  5a  68  76  84  92  a0  ak  bi  cg  de  ec  fa  g8  h6  i4  j2  k0
   l  1k  2j  3i  4h  5g  6f  7e  8d  9c  ab  ba  c9  d8  e7  f6  g5  h4  i3  j2  k1  l0
  10  20  30  40  50  60  70  80  90  a0  b0  c0  d0  e0  f0  g0  h0  i0  j0  k0  l0 100

— ormaaj
स्रोत

0

पाइके, 14 बाइट्स * 0.8 = 11.2 बाइट्स, नॉन-कंपेटिटिव

QhD]UA*MbQMl2P

यहाँ कोशिश करो!

स्पष्टीकरण:

            - autoassign Q = eval_or_not_input()
QhD]        - [Q+1, Q+1]
    U       - nd_range(^)
     A*     - apply(*, ^)
       MbQ  - map(base(Q), ^)
          Ml2 - map(lower, ^)
          P - print_grid(^)

या बोनस के बिना 12 बाइट्स

13D]UA*Mb12P

— नीला
स्रोत

चुनौती अपरकेस अक्षरों को निर्दिष्ट करती है

— लुइस मेंडो

चीला के लिए एक गुणन तालिका

विस्तारित चुनौती और बोनस

पायथ, 27 * 0.8 = 21.6

स्पष्टीकरण:

सीजाम, 33 * 0.8 = 26.4 बाइट्स

व्याख्या

MATL , 42 * .8 = 33.6

अस्वीकरण

कोड

उदाहरण

व्याख्या

संपादित करें: इसे ऑनलाइन आज़माएं!

बैश + बीएसडी उपयोगिताओं, 36

पायथ, 36 बाइट्स

पायथन, 153 147 132 बाइट्स * 0.8 = 105.6

CJam, 38 33 32 38 * (.8) = 30.4 बाइट्स

पर्ल 6 , 60 बाइट्स -20% = 48 बाइट्स

जावास्क्रिप्ट (ईएस 6) 84 (105-20%)

पायथन 3, 126 - 20% = 100.8 बाइट्स

जावास्क्रिप्ट (ES6) 96.8 93.6 बाइट्स (117 का 20%)

व्याख्या

MATLAB, 111 * 0.8 = 88.8 110 * 0.8 = 88 बाइट्स

पायथन 3: 166 161 152 - 20% = 121.6 बाइट्स

एपीएल, 32 31 × 0.8 = 24.8 बाइट्स

रूबी, 69 66 अक्षर - 20% = 52.8

ksh93, 51 * 0.8 == 40.8 बाइट्स

पाइके, 14 बाइट्स * 0.8 = 11.2 बाइट्स, नॉन-कंपेटिटिव