अंकगणित-सारणी के पूर्णांक-अंक


17

चुनौती:

इनपुट के आधार पर निम्नलिखित छह अंकगणितीय-तालिकाओं में से एक का 'पूर्णांक-अंक' आउटपुट:
- जोड़ ( +);
- घटाव ( -);
- गुणन ( *);
- विभाजन ( /);
- घातांक ( ^);
- मोडुलो ऑपरेशन ( %)।

नियम:

  • अंकगणित संकार्य जो वास्तव में निम्नलिखित में से एक है की हर परिणाम:: मैं 'के रूप में पूर्णांक अंक' क्या परिभाषित करते हैं 0, 1, 2, 3, 4, 5, 6, 7, 8, 9। इसका मतलब है आप को बाहर के हर परिणाम 10या अधिक, के हर परिणाम -1या कम है, और हर गैर पूर्णांक परिणाम।
  • हम अंकगणितीय परिणामों की गणना कैसे करते हैं: पहले शीर्ष अंक का उपयोग करके, और फिर बाएं अंक के साथ ऑपरेंड का उपयोग करें। जब तक आप आउटपुट के सभी छह के लिए सुसंगत हैं, तब तक आपको y/xइसके विपरीत (यानी के बजाय x/y) करने की अनुमति है ! (इसलिए आपको उपयोग करने की अनुमति नहीं हैy-x और x/yएक ही जवाब में।)
  • हम 0 परीक्षण-मामलों द्वारा विभाजन के लिए कुछ भी आउटपुट नहीं करेंगे (विभाजन और मॉडुलो ऑपरेशन टेबल के लिए)
  • हम बढ़त-मामले के लिए कुछ भी आउटपुट नहीं करेंगे 0^0

आउटपुट:

इसलिए आउटपुट निम्न है (तालिका प्रारूप कुछ लचीला है (नीचे देखें): इसलिए लाइनें वैकल्पिक हैं और मुख्य रूप से परीक्षण मामलों की पठनीयता के लिए जोड़ी गई हैं:

इसके अलावा:

+ | 0 1 2 3 4 5 6 7 8 9
-----------------------
0 | 0 1 2 3 4 5 6 7 8 9
1 | 1 2 3 4 5 6 7 8 9
2 | 2 3 4 5 6 7 8 9
3 | 3 4 5 6 7 8 9
4 | 4 5 6 7 8 9
5 | 5 6 7 8 9
6 | 6 7 8 9
7 | 7 8 9
8 | 8 9
9 | 9

घटाव:

- | 0 1 2 3 4 5 6 7 8 9
-----------------------
0 | 0 1 2 3 4 5 6 7 8 9
1 |   0 1 2 3 4 5 6 7 8
2 |     0 1 2 3 4 5 6 7
3 |       0 1 2 3 4 5 6
4 |         0 1 2 3 4 5
5 |           0 1 2 3 4
6 |             0 1 2 3
7 |               0 1 2
8 |                 0 1
9 |                   0

गुणा:

* | 0 1 2 3 4 5 6 7 8 9
-----------------------
0 | 0 0 0 0 0 0 0 0 0 0
1 | 0 1 2 3 4 5 6 7 8 9
2 | 0 2 4 6 8
3 | 0 3 6 9
4 | 0 4 8
5 | 0 5
6 | 0 6
7 | 0 7
8 | 0 8
9 | 0 9

विभाजन:

/ | 0 1 2 3 4 5 6 7 8 9
-----------------------
0 | 
1 | 0 1 2 3 4 5 6 7 8 9
2 | 0   1   2   3   4
3 | 0     1     2     3
4 | 0       1       2
5 | 0         1
6 | 0           1
7 | 0             1
8 | 0               1
9 | 0                 1

घातांक:

^ | 0 1 2 3 4 5 6 7 8 9
-----------------------
0 |   1 1 1 1 1 1 1 1 1
1 | 0 1 2 3 4 5 6 7 8 9
2 | 0 1 4 9
3 | 0 1 8
4 | 0 1
5 | 0 1
6 | 0 1
7 | 0 1
8 | 0 1
9 | 0 1

सापेक्ष:

% | 0 1 2 3 4 5 6 7 8 9
-----------------------
0 | 
1 | 0 0 0 0 0 0 0 0 0 0
2 | 0 1 0 1 0 1 0 1 0 1
3 | 0 1 2 0 1 2 0 1 2 0
4 | 0 1 2 3 0 1 2 3 0 1
5 | 0 1 2 3 4 0 1 2 3 4
6 | 0 1 2 3 4 5 0 1 2 3
7 | 0 1 2 3 4 5 6 0 1 2
8 | 0 1 2 3 4 5 6 7 0 1
9 | 0 1 2 3 4 5 6 7 8 0

चुनौती नियम:

  • अनुगामी नई-लाइनें और अनुगामी स्थान वैकल्पिक हैं
  • परीक्षण मामलों में क्षैतिज और ऊर्ध्वाधर लाइनें वैकल्पिक हैं। मैंने केवल उन्हें बेहतर पठनीयता के लिए जोड़ा।
  • प्रत्येक परिणाम के बीच रिक्त स्थान वैकल्पिक नहीं हैं।
  • अंकगणित का प्रतीक भिन्न हो सकता है, जब तक कि यह स्पष्ट है कि यह कौन सा है। Ie ×या ·इसके बजाय *गुणा के लिए; विभाजन के ÷बदले /; आदि
    और जब तक यह एक है एक चरित्र है, तो माफ करना पायथन के **
  • इनपुट प्रारूप लचीला है। आप संबंधित छह तालिकाओं के लिए 0-5 या 1-6 से एक सूचकांक चुन सकते हैं; आप ऑपरेंड-प्रतीक इनपुट कर सकते हैं; आदि (आप परिणाम में क्या प्रदर्शित करते हैं, इसके विपरीत, आपको पूर्ण स्ट्रिंग्स इनपुट करने की अनुमति है, या **पायथन के मामले में।)
    बस यह सुनिश्चित करें कि आप अपने उत्तर में किस इनपुट-प्रारूप का उपयोग करते हैं!

सामान्य नियम:

  • ये है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
    कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव संक्षिप्त उत्तर के साथ आने का प्रयास करें।
  • मानक नियम आपके उत्तर के लिए लागू होते हैं , इसलिए आपको उचित पैरामीटर, पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति है। तुम्हारा फोन।
  • डिफ़ॉल्ट कमियां निषिद्ध हैं।
  • यदि संभव हो, तो कृपया अपने कोड के लिए एक परीक्षण के साथ एक लिंक जोड़ें।
  • इसके अलावा, यदि आवश्यक हो तो एक स्पष्टीकरण जोड़ें।

† क्षैतिज और ऊर्ध्वाधर लाइनों के बिना वैध आउटपुट का उदाहरण, ÷प्रतीक के रूप में, और y/xइसके बजाय का उपयोग करना x/y:

÷ 0 1 2 3 4 5 6 7 8 9
0   0 0 0 0 0 0 0 0 0
1   1
2   2 1
3   3   1
4   4 2   1
5   5       1
6   6 3 2     1
7   7           1
8   8 4   2       1
9   9   3           1

यदि हमारी भाषा में परिणाम है, तो शून्य से विभाजन के लिए परिणाम ठीक है? उदाहरण के लिए APL में, 0 is 0 डिफ़ॉल्ट रूप से 1 है, और N mod-0 N है? एक अलग योजना भी चुन सकते हैं जहाँ शून्य से विभाजन हमेशा शून्य हो।
12

क्या हमें स्तंभों के बीच एक से अधिक स्थान की अनुमति है?
आदम

@ अंतिम प्रतिक्रिया के लिए क्षमा करें। अपने पहले सवाल के रूप में: कोई खेद नहीं है। मुझे पता है कि कुछ भाषाएं प्रिंट 1, अन्य 0, दूसरों को कुछ और के लिए 0^0या विभाजित / मॉड 0, लेकिन आपको इसके आसपास काम करना होगा। अपने दूसरे प्रश्न के रूप में: हाँ सुनिश्चित करें, जब तक कि अंक अभी भी उसी कॉलम / पंक्तियों में हैं जो आप जितनी चाहें उतने रिक्त स्थान का उपयोग कर सकते हैं।
केविन क्रूज़सेन

क्या गैर-कम्यूटेटिव ऑपरेशन के लिए तर्कों का क्रम महत्वपूर्ण है?
आदम

@ एडम तो तुम मतलब है कि आप उत्पादन के लिए ग्रिड हूँ y-x, y/x, y^xऔर y%xके बजाय x-y, x/y, x^yऔर x%y? हम्म, मुझे लगता है कि ठीक हो सकता है। मैं इसे उत्तर में संपादित करूँगा; जब तक आप उनमें से सभी छह के लिए संगत होंगे (तब तक y-xऔर x/yउसी उत्तर में नहीं)।
केविन क्रूज़सेन

जवाबों:


7

जाप , 45 बाइट्स

@ETHproductions के साथ सहयोग किया गया

AÆAÇU¥'p«Z«XªOvZ+U+X)+P r"..+"SÃuXÃuAo uU)m¸·

इसे ऑनलाइन चलाएं!

इनपुट के रूप में लेता है:

"+" जोड़ के लिए

"-" घटाव के लिए

"*" गुणन के लिए

"/" विभाजन के लिए

"p" प्रतिपादक के लिए

"%" modulo के लिए

स्पष्टीकरण (विस्तारित शॉर्टकट के साथ):

AÆ  AÇ  U¥ 'p«  Z«  Xª OvZ+U+X)+P r"..+"SÃ uXÃ uAo uU)m¸  ·
AoX{AoZ{U=='p&&!Z&&!X||OvZ+U+X)+P r"..+"S} uX} uAo uU)mqS qR

A                                                             // By default, 10 is assigned to A
 o                                                            // Create a range from [0...9]
  X{                                         }                // Iterate through the range, X becomes the iterative item
    Ao                                                        //   Create another range [0...9]
      Z{                                 }                    //   Iterate through the range, Z becomes the iterative item
                                                              //     Take:
        U=='p                                                 //       U (input) =="p"
             &&!Z                                             //       && Z != 0
                 &&!X                                         //       && X != 0
                     ||                                       //     If any of these turned out false, instead take
                       Ov                                     //       Japt Eval:
                         Z+U+X                                //         Z{Input}X
                              )+P                             //     Whichever it was, convert to a string
                                  r"..+"S                     //     Replace all strings of length 2 or more with " "
                                                              //     (this makes sure the result !== "false" and has length 1)
                                           uX                 //   Insert X (the row number) into the front of the row
                                               u              // Insert at the beginning the first row:
                                                Ao            //   [0...9]
                                                   uU)        //   with the input inserted at the beginning
                                                      mqS     // Join each item in the final array with " "
                                                          qR  // Join the final array with "\n"

8

जावास्क्रिप्ट (ईएस 7), 128 बाइट्स

f=
c=>[...c+`0123456789`].map((r,_,a)=>a.map(l=>l==c?r:r==c?l:/^\d$/.test(l=c<`^`?eval(l+c+r):l|c?l**r:l/r)?l:` `).join` `).join`
`
<select onchange=o.textContent=f(this.value)><option>><option>+<option>-<option>*<option>/<option>%<option>^<option>&<option>,<option>.</select><pre id=o>

विशेष-आवरण की 0^0लागत मुझे 8 बाइट्स।


बहुत अच्छा है कि आपने अपने परीक्षण-स्निपेट को OR और AND जैसे अतिरिक्त ऑपरेंड कैसे जोड़े हैं। +1
केविन क्रूज़सेन

@ केविनक्रूजसेन मुझे एक बाइट निकालने के लिए या (सभी अन्य ऑपरेटरों को पहले छाँटने ^) को बचाना था , लेकिन धन्यवाद!
नील

5

ऑपरेशन फ्लैशपॉइंट स्क्रिप्टिंग भाषा, 343 333 303 301 बाइट्स

f={o=_this;s=o+" 0 1 2 3 4 5 6 7 8 9\n";i=0;while{i<10}do{j=0;s=s+format["%1",i];if(i<1&&(o=="/"||o=="%"||o=="^"))then{if(o=="^")then{if(j<1)then{s=s+"  ";j=1}}else{s=s+"\n1";i=1}};while{j<10}do{r=call format["%1%2%3",j,o,i];if(r>9||r<0||r%1>0)then{r=" "};s=s+format[" %1",r];j=j+1};s=s+"\n";i=i+1};s}

के साथ बुलाना:

hint ("+" call f)

Ungolfed:

f=
{
    o=_this;
    s=o+" 0 1 2 3 4 5 6 7 8 9\n";
    i=0;
    while{i<10}do
    {
        j=0;
        s=s+format["%1",i];
        if(i<1&&(o=="/"||o=="%"||o=="^"))then
        {
            if(o=="^")then{if(j<1)then{s=s+"  ";j=1}}
            else{s=s+"\n1";i=1}
        };
        while{j<10}do
        {
            r=call format["%1%2%3",j,o,i];
            if(r>9||r<0||r%1>0)then{r=" "};
            s=s+format[" %1",r];
            j=j+1
        };
        s=s+"\n";
        i=i+1
    };
    s
}

आउटपुट:

संचालक +

ऑपरेटर -

ऑपरेटर *

ऑपरेटर /

संचालक ^

ऑपरेटर %


5

पायथन 2 , 240 231 226 224 203 202 200 197 बाइट्स

a=i=input()
R=range(10)
for z in R:a+=' '+`z`
print a
for x in R:
 try:
	d=`x`
	for b in R:c=eval("b%s(x*1.)"%('**',i)[i<'^']);d+=' '+(' ',`int(c)`)[(i<'^'or x+b>0)and c in R]
 except:pass
 print d

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

"+", "-", "*", "/", "^" या "%" में से एक के रूप में इनपुट लेता है।

संपादित करता

-9 -16 कुछ महान संकेत के लिए @FelipeNardiBatista के लिए धन्यवाद

221 से नीचे @FelipeNardiBatista से अधिक मदद और फिर हारकर 203 तक and E(c)==int(E(c))। अगर हम जाँच कर रहे हैं अगरE(c) है में range(10)यह हमेशा एक पूर्णांक हो सकता है अगर यह नहीं है। डुप्लीकेट चेक की कोई जरूरत नहीं।

यह है अजगर 3 का उपयोग करने जा और घोषणा के बिना 200 से कम जाने के लिए P=print। कोई विचार? मैं हमेशा सीखने के लिए खुश हूं।

Yesss! मुझे पता था कि यह किया जा सकता है। 197. अभी बिस्तर का समय है। मैंने इस पर पर्याप्त समय बिताया है। दिलचस्प चुनौती @KevinCruijssen के लिए धन्यवाद।


1
('**',i)[i<'^']और (i<'^'or x>0 or b>0)4 बाइट्स बचाता है
फेलिप नारदी बतिस्ता

1
a=i=input()साथ for z in R:a+=' '+`z`के लिए कुछ अतिरिक्त बनाम बचाया बाइटa=i+' 0 1 2 3 4 5 6 7 8 9'
फेलिप Nardi बतिस्ता

1
1.बनाम 1.0और E(c)in Rबनाम -1<E(c)<102 बाइट्स के लिए
फेलिप नारदी बतिस्ता

1
x+b>0बनाम x>0 or b>0और "b%s(x*1.)"%('**',i)[i<'^']बनाम"b"+('**',i)[i<'^']+"(x*1.)"
फेलिप नारदी बतिस्ता

1
वहाँ अतिरिक्त कोष्ठक का एक सेट है (, )अपने लिए शामिल होने के 223 बाइट में
फेलिप Nardi बतिस्ता

4

मैथेमेटिका, 150 बाइट्स

r=0~Range~9;p=Prepend;±i_:=Grid@p[p[If[0<=#<=9,#]/._@__->""&/@<|Thread[Characters@"+-*/^%"->{Plus,#-#2&,1##&,#/#2&,Power,Mod}]|>[i][r,#],#]&/@r,r~p~i]

एक एकात्मक कार्य को परिभाषित करता है ±वर्णों +-*/^%में से किसी एक को इसके इनपुट के रूप मेंi (इसलिए उदाहरण के लिए ±"^"), और वापस लौटता हैGrid ओपी में अंतिम आउटपुट की तरह दिखने वाली वस्तु को ।

<|Thread[Characters@"+-*/^%"->{Plus,#-#2&,1##&,#/#2&,Power,Mod}]|>सहयोगी, प्रत्येक संभव इनपुट चरित्र के लिए, संबंधित (सूची में) बाइनरी फ़ंक्शन (जहां #-#2&,1##&,#/#2&गोल्फ संस्करण हैं Subtract,Times,Divide); इसलिए <|...|>[i][r,#]सभी संभावित पहले तर्कों और #दूसरे तर्क के रूप में बाइनरी ऑपरेशन की गणना करता है। If[0<=#<=9,#]/._@__->""&प्रत्येक परिणाम को एक में परिवर्तित करता है Nullया ""यदि यह एकल-अंकीय परिणाम नहीं है ( /._@__->""आवश्यक है क्योंकि कुछ परिणाम जैसे 1/0असमानताओं द्वारा संसाधित नहीं किए जा सकते हैं 0<=#<=9)। अंत में, हम विभिन्न शीर्ष लेख और पाद लेख प्रस्तुत करते हैं और उत्तर प्रदर्शित करते हैं।


अच्छा जवाब और स्पष्टीकरण। क्या आपके पास कोशिश-ऑनलाइन लिंक है? और एक प्रश्न / ध्यान दें, मुझे किनारे-केस नियम का कोई उल्लेख नहीं दिखाई देता है: " हम एज-केस के लिए कुछ भी आउटपुट नहीं करेंगे 0^0 क्या मैथेमेटिका इस एज-केस के लिए डिफ़ॉल्ट रूप से कुछ भी आउटपुट नहीं करता है?"
केविन क्रूज़सेन

1
मैंने ऊपर एक लिंक जोड़ा। गणितज्ञ का मूल्यांकन करता 0^0है Indeterminate, जो हमें एक दुखी unevaluated परिणाम If[0<=Indeterminate<=9, Indeterminate]मध्य-संगणना देता है; लेकिन /._@__->""एक ऐसा नियम है जो किसी भी अविकसित फ़ंक्शन और उसके तर्कों को लेता है और इसे एक अदृश्य स्ट्रिंग में बदल देता है।
ग्रेग मार्टिन

आह ठीक है, इसलिए गणितज्ञ सही ढंग से यह कहते हैं कि दो परस्पर विरोधी नियम #^0=1और 0^#= 0` के लिए हो रहे हैं 0^0। अब के लिए अच्छा है, और इस चुनौती के लिए सुविधाजनक है। :) Btw, आपका लिंक काम नहीं कर रहा है। मुझे एक त्रुटि मिलती है कि मुझे इसे एक्सेस करने की कोई अनुमति नहीं है।
केविन क्रूज़सेन

ठीक है, आपको sandbox.open.wolframcloud.com पर जाना होगा और अपने आप में कोड पेस्ट करना होगा, फिर इसे एक कमांड के साथ कॉल करें ±"^"
ग्रेग मार्टिन

4

पायथन 3, 343 335 363 362 बाइट्स

इस बारे में सबसे दुखद बात यह है कि एक जावा जवाब मुझे मार रहा है ... मैं इसे सुबह और अधिक गोल्फ दूंगा।

o=input()
r=range(10)
g=[['']*10 for i in r]
for x in r:
 for y in r:exec('if"/"!=o and(o!="%"or x)and(o!="**"or x or y):k=str(y'+o+'x);g[x][y]=k')
if'/'==o:
 for x in r:
  for y in r:
   if x and y%x<1:g[x][y]=str(round(y/x))
if'**'==o:o='^'
print('\n'.join([' '.join([o]+list(map(str,r)))]+[' '.join([str(q)]+[' 'if len(x)!=1else x for x in g[q]])for q in r]))

ReplIT


बढ़त मामले से बचने के लिए एक डबल लूप 5: बाइट्स के बजाय सूची समझ पर स्विच करके -8 बाइट्स 0 ^ 0। -.-
1 बाइट के ==0लिए <1धन्यवाद में बदलकर @StewieGriffin


" इस बारे में सबसे दुखद बात यह है कि एक जावा उत्तर मुझे पीट रहा है ... " इस भाग ने मुझे गदगद कर दिया .. एक्सडी मुझे पसंद है कि आप यह निर्धारित करने की संख्या की लंबाई की जांच कर रहे हैं कि यह किस सीमा में है 0-9। Btw, umm .. मैंने आपकी प्रतिकृति में एक त्रुटि देखी। यह वर्तमान में घातांक के **बजाय आउटपुट देता है ^। (इसके अलावा, आपको इनपुट करने की अनुमति है **, लेकिन इसे परिणाम-तालिका में आउटपुट करने के लिए नहीं। वर्तमान में आपके पास इसका दूसरा तरीका है।)
केविन क्रूज़सेन

1
@KevinCruijssen वूप्स। सफलतापूर्वक निर्धारित किया गया, कोई बाइट गिनती परिवर्तन नहीं। यह बात बताने के लिए धन्यवाद!
हाइपरनेत्रिनो

@StewieGriffin हाँ। धन्यवाद।
हाइपरएन्यूट्रीनो 12

4

जावा 7, 312 305 बाइट्स

String c(int o){String r=("+-*/^%".charAt(o))+" 0 1 2 3 4 5 6 7 8 9\n";for(int i=0,j,p;i<10;i++){r+=i+" ";for(j=0;j<10;r+=p<0|p>9?"  ":p+" ")p=p(o,i,j++);r+="\n";}return r;}int p(int o,int a,double b){b=o<1?b+a:o<2?b-a:o<3?b*a:o<4&a>0?b/a:o<5&(a!=0|b!=0)?Math.pow(b,a):a>0?b%a:-1;return b%1==0?(int)b:-1;}

कोई क्षैतिज / ऊर्ध्वाधर रेखाओं का उपयोग नहीं करता है, और वर्णों को चुनौती-उदाहरणों ( +-*/^%) में प्रदर्शित किया जाता है । इनपुट के रूप में छह गणितीय ऑपरेंड्स
के 0-5लिए एक इंडेक्स का उपयोग करता है ।

-7 बाइट्स @Frozn को धन्यवाद ।

स्पष्टीकरण:

String c(int o){                   // Method with integer parameter and String return-type
  String r = ("+-*/^%".charAt(o))  //  Get the current mathematical operand character based on the input index
    + " 0 1 2 3 4 5 6 7 8 9\n";    //  Append the column header and a new-line
  for(int i=0,j,p; i<10; i++){     //  Loop over the rows
    r += i+" ";                    //   Append the left-side row-nr
    for(j=0; j<10;                 //   Inner-loop over the columns of the current row
        r += p<0|p>9?"  ":p+" ")   //     And after every iteration, append the result with either a space or an integer
      p = p(o,i,j++);              //    Calculate the current sum-result
                                   //   End of inner-loop (implicit / single-line body)
    r+="\n";                       //   Append result with new-line
  }                                //  End of loop
  return r;                        //  Return result String
}                                  // End of method

int p(int o,int a,double b){       // Separate method with two integer and a double parameters and integer return-type
  b = o<1 ?                        //  If the given operand is 0:
       b+a                         //   Use addition
      : o<2 ?                      //  Els-if the given operand is 1:
       b-a                         //   Use subtraction
      : o<3 ?                      //  Else-if the given operand is 2:
       b*a                         //   Use multiplication
      : o<4 & a>0 ?                //  Else-if the given operand is 3 and `a` is above 0:
       b/a                         //   Use division
      : o<5 & (a!=0|b!=0) ?        //  Else-if the given operand is 4 and not both `a` and `b` are 0:
       Math.pow(b,a)               //   Use exponentiation
      : a>0 ?                      //  Else-if the given operand is 5:
       b%a                         //   Use modulo
      :                            //  Else:
       -1;                         //   Use -1 as result
  return b%1 == 0 ?                //  If the result is not a decimal number:
     (int)b                        //   Return the result
    :                              //  Else:
     -1;                           //   Return -1 as result
}                                  // End of separate method

टेस्ट कोड:

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

class M{
  String c(int o){String r=("+-*/^%".charAt(o))+" 0 1 2 3 4 5 6 7 8 9\n";for(int i=0,j,p;i<10;i++){r+=i+" ";for(j=0;j<10;r+=p<0|p>9?"  ":p+" ")p=p(o,i,j++);r+="\n";}return r;}int p(int o,int a,double b){b=o<1?b+a:o<2?b-a:o<3?b*a:o<4&a>0?b/a:o<5&(a!=0|b!=0)?Math.pow(b,a):a>0?b%a:-1;return b%1==0?(int)b:-1;}

  public static void main(String[]a){
    M m = new M();
    System.out.println(m.c(0)); // +
    System.out.println(m.c(1)); // -
    System.out.println(m.c(2)); // *
    System.out.println(m.c(3)); // /
    System.out.println(m.c(4)); // ^
    System.out.println(m.c(5)); // %
  }
}

1
हो सकता है आप दे सकते हैं bएक के रूप में doubleकरने के लिए pऔर से छुटकारा पाने के rश्रृंखलित त्रिगुट के मूल्य बताए द्वारा b
Frozn

3

हास्केल, 230 199 182 + 53 47 46 + 1 विभाजक का बाइट = 284 247 232 229 बाइट्स

f=head.show
g=[0..9]
h=(:" ")
y(%)s=unlines$(s:map f g>>=h):[f y:[last$' ':[f(x%y)|x%y`elem`g]|x<-g]>>=h|y<-g]
0?0=10;a?b=a^b
a!0=10;a!b|(e,0)<-a`divMod`b=e|1>0=10
a&0=10;a&b=mod a b

समारोह है (zipWith y[(+),(-),(*),(!),(?),(&)]"+-*/^%"!!) , जो अकेले 53 बाइट्स लेता है, जहां 0 अतिरिक्त है, 1 घटाव है, 2 गुणा है, 3 विभाजन है, 4 घातांक है, और 5 मॉडुलो है।

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

व्याख्या

बाद में आना (संभवतः)। । । । अभी कुछ छोटी चिड़ियों के लिए:? प्रतिपादक ऑपरेटर है,! डिवीजन ऑपरेटर है, और & मॉड ऑपरेटर है।

संपादित करें: थोक का एक हिस्सा हो सकता है क्योंकि अन्य उत्तरों के अधिकांश (?) Eval का उपयोग करते हैं, जो हास्केल के पास एक लंबी अवधि के आयात के बिना नहीं है।

EDIT2: -31 बाइट्स के लिए धन्यवाद अर्जन जोहान्सन (वाह!) कोड और -6 बाइट्स ऑफ द फंक्शन बंद! निरंतर उद्देश्यों के लिए 11s से 10s में से कुछ को भी बदल दिया। अपडेट किए गए संस्करण को ऑनलाइन आज़माएं!

EDIT3: वही व्यक्ति, सत्रह अधिक बाइट्स! अद्यतन, अद्यतन संस्करण ऑनलाइन की कोशिश करो!


1
छोटा !परीक्षण: e<-a`div`b,e*b==a=eया (e,0)<-a`divMod`b=e
अर्जन जोहान्सन

1
शोर्टर फंक्शन:(zipWith(#)"+-*/^%"[(+),(-),(*),(!),(?),(&)]!!)
अर्जन जोहान्सन

रिवर्सिंग टेस्ट + एक "मानक" गोल्फिंग चाल देता है last$f k:[' '|k<0||k>9]। अंत में (शायद), [0..9]बस इतना लंबा है कि वह इसे दो बार उपयोग करते समय एक नाम के रूप में परिभाषित करने के लिए भुगतान करता है।
अर्जन जोहान्सन

नहीं, एक और: k<-[o x y]एक से कम है let
अर्जन जोहान्सन

एक शब्द: वाह! :)
जेनेरिक डिस्प्ले नाम

2

पायथन 2 , 197 बाइट्स

p=input()
r=range(10)
s=' '
print p+s+s.join(map(str,r))
for i in r:print str(i)+s+s.join(eval(("s","str(j"+p+"i)")[i and(j%i==0 and'/'==p or'%'==p)or p in'**+-'and eval("j"+p+"i")in r])for j in r)

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

इनपुट: पायथन 2

'+' इसके अलावा

'-' Sbtraction

'*' गुणन

'/' विभाजन

'**' घातांक

'%' modulo

पायथन 3 , 200 बाइट्स

p=input()
r=range(10)
s=' '
print(p+s+s.join(map(str,r)))
for i in r:print(str(i)+s+s.join(eval(("s","str(j"+p+"i)")[i and(j%i==0 and'/'in p or'%'==p)or p in'**+-'and eval("j"+p+"i")in r])for j in r))

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

इनपुट: पायथन 3

+ इसके अलावा

- Sbtraction

* गुणन

// विभाजन

** घातांक

% modulo

व्याख्या

range(10)एक चर के लिए भंडारण r, हम प्रारूप के आउटपुट की पहली पंक्ति प्राप्त कर सकते हैं

operator 0 1 2 3 4 5 6 7 8 9

rस्ट्रिंग में प्रत्येक इंट को मैप करके और ऑपरेटर के ['0','1','2','3','4','5','6','7','8','9']साथ अंतरिक्ष के sसाथ स्ट्रिंग सूची में शामिल होp

p+s+s.join(map(str,r)

कि के साथ, हर के लिए iमें r(रेंज), हर एक के लिए jमूल्यांकन iऔर jअपने ऑपरेटर के साथ

eval("j"+p+"i")

यहां, यदि अपवाद को खंडित किया गया है तो एक अपवाद को फेंक दिया जा सकता है - इस मामले को संभालने के लिए विभाजन (या मापांक i and(j%i==0 and'/'==p or'%'==p)) और समस्या विवरण में वर्णित आउटपुट स्वरूप (प्रत्येक मूल्यांकन के लिए परिणाम एक नकारात्मक संख्या नहीं होनी चाहिए और न ही एक संख्या से अधिक होना चाहिए) 10 - eval("j"+p+"i")in r),

i and(j%i==0 and'/'==p or'%'==p)or p in'**+-'and eval("j"+p+"i")in r

इस प्रकार अंकगणित-तालिका की छपाई!

हैप्पी कोडिंग!


अच्छा अजगर 2 जवाब। 197 पर लगता है कि हमें बराबर बनाता है। इसने मुझे कुछ और प्रयास किए। बहुत बढ़िया। थोड़ी सी समस्या। के लिए / तालिका दिखाता है .0 और पूर्णांक नहीं। यकीन है कि आसानी से ठीक किया जाता है :)
ElPedro

क्षमा करें, लेकिन एक बार जब मैंने देखा कि मेरे अपवोट को वापस ले लिया है, तो इसे फिर से जोड़ देंगे, एक बार जब आपको इसे सही करने का मौका मिला है :)
ElPedro

धन्यवाद! यदि आप इनपुट के रूप में '/' का उपयोग करते हैं तो पायथन 2 प्रिंट इंट और अजगर 3 प्रिंट तैरते हैं। फेर पायथन 3 आपको '//' का उपयोग करना है। मैंने स्पष्ट रूप से उल्लेख किया है।
कीर्तन प्रभाकरन

और ऐसा लगता है कि कोई मेरे लिंक को संपादित कर रहा है और ते अजगर 2 लिंक को अजगर में बदल दिया गया है 3. मैंने इसे अब वापस कर दिया है।
कीर्तन प्रभाकरन

मुझे पहले भी यह समस्या रही है। ऐसा इसलिए है क्योंकि आपके पास एक ही पृष्ठ पर 2 TOI लिंक हैं। जब आप या तो लिंक पर क्लिक करते हैं तो यह पहली लिंक परिभाषा को खोलेगा जो इसे ढूंढती है। दूसरा लिंक "इसे ऑनलाइन 3 आज़माएं" या कुछ और का नाम बदलकर और इसकी परिभाषा को भी बदल दें। तब ठीक काम करना चाहिए।
एलपेड्रो

2

एपीएल (डायलॉग) , 68 76 बाइट्स

⎕IO←0कई सिस्टम पर डिफ़ॉल्ट की आवश्यकता होती है। इनपुट के लिए संकेत और एक एकल चरित्र का प्रतिनिधित्व करने की उम्मीद है।

t'|'=w←⎕
(w,n),n⍪⍉⍣t∘.{(⍺w⍵≡0'*'0)∨(t∧⍵≡0)∨⍺w0'÷':⍬
n∊⍨r←⍵(⍎w)⍺:r
⍬}⍨n←⍳10

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

अधिकांश कोड APL के परिणामों को दरकिनार करते हैं ÷0 और 0*0और प्रतिक्रिया है कि एपीएल के सापेक्ष (करने के लिए |) अपने तर्कों सबसे अन्य भाषाओं की तुलना में उलट गया है। अन्यथा केवल 41 बाइट्स होते:

w←⎕
(w,n),n⍪∘.{0::⍬
÷n∊⍨r←⍵(⍎w)⍺:r}⍨n←⍳10

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


वाह! और मेरे अजगर जवाब पर मेरी कड़ी मेहनत के बाद। फेयर प्ले।
एलपीड्रो 20

1

आर , 194 177 बाइट्स

मैट्रिक्स आउटपुट में हेरफेर करने के लिए -17 बाइट्स स्विचिंग

function(o){s=0:9
y=sapply(s,function(x)Reduce(o,x,init=s))
dimnames(y)=list(s,rep('',10))
y[!y%in%s|!is.finite(y)]=' '
if(o=='^')y[1]=' '
cat(substr(o,1,1),s)
print(y,quote=F)}

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

इस दृष्टिकोण में परिवर्तन के कुछ डाउनसाइड हैं, अर्थात् इसका उपयोग करके अनुकूलित नहीं किया जा सकता है pryr और मूल मैट्रिक्स को सेट करने के लिए थोड़ा क्लंकी है, लेकिन यह पहली पंक्ति में कुछ अनुगामी स्थानों के साथ पूरी तरह से आउटपुट हो सकता है।

मुझे अभी भी मॉड ऑपरेटर के substrकारण चाल का उपयोग करना है %%। मौका मिलते ही इसे ट्रिम करना जारी रखूंगा, यह अभी भी विशेष मामलों से निपटने में बहुत ही भद्दा लगता है।


0

PHP, 191 बाइट्स

**^इनपुट के बजाय+ - / % * **

echo$k=$argn,$k=="**"?"":" ",join(" ",$d=range(0,9));foreach($d as$r){echo"\n$r";foreach($d as$c){echo" ";($k=="/"|($m=$k=="%"))&$r<1?print" ":eval("echo in_array($c$k$r,\$d)?$c$k$r:' ';");}}

दोनों संस्करणों के ऑनलाइन संस्करण

PHP, 245 बाइट्स eval के बिना

इनपुट + - / % * ^

bcpowmod($c,1,$r)इसके बजाय उपयोग करें bcmod($c,$r)क्योंकि मुझे डिवीजन इनपुट में तीसरे पैरामीटर की आवश्यकता है। $c**1%$r==$c%$r

ईसा पूर्व गणित के कार्य

echo$k=$argn," ".join(" ",$d=range(0,9));foreach($d as$r){echo"\n$r";foreach($d as$c)echo" ",in_array($s=($k=="/"|($m=$k=="%"))&$r<1?-1:("bc".["+"=>add,"-"=>sub,"/"=>div,"*"=>mul,"^"=>pow,"%"=>powmod][$k])($c,$m?1:$r,$m?$r:9),$d)?round($s):" ";}

0

05AB1E , 56 55 बाइट्स

9ÝDãεðýì„/%Iåyθ_*I'mQyO_*~iðë.VD9ÝQàiïëð]«TôεN<š}®I:ðý»

लाइनों के बिना और उलट साथ आउटपुट xऔर y। इनपुट / आउटपुट का उपयोग कर रहे +, -, *, /, m, %

इसे ऑनलाइन आज़माएं या सभी तालिकाओं को सत्यापित करें

21 बाइट्स ठीक किनारे मामलों के लिए उपयोग किया जाता है /0, %0और 0^0है, जो में परिणाम 0, 0और 1क्रमशः 05AB1E में .. यहाँ उस भाग के बिना ( 34 बाइट्स ):

9ÝDãεðýì.VD9ÝQàiïëð]«TôεN<š}®I:ðý»

इसे ऑनलाइन आज़माएँ या सभी तालिकाएँ आज़माएँ

स्पष्टीकरण:

9Ý                     # Push list [0,1,2,3,4,5,6,7,8,9]
  D                    # Duplicate it (for the header later on)
   ã                   # Take the cartesian product with itself (creating all pairs):
                       #  [[0,0],[0,1],[0,2],...,[9,7],[9,8],[9,9]]
ε                      # Map each pair `y` to:
 ðý                    #  Join the pairs with a space
   ì                   #  Prepend it before the (implicit) input-char 
 „/%Iå                 #   If the input is "/" or "%"
         *             #   and
      yθ_              #   The last value of the pair is exactly 0
                  ~    #  OR
          I'mQ        '#   If the input is "m"
                 *     #   and
              yO_      #   The sum of the pair is exactly 0 (thus [0,0])
 i                     #  If that is truthy:
  ð                    #   Push a space character " "
 ë                     #  Else:
  .V                   #   Execute the string as 05AB1E code
    D                  #   Duplicate the result
     9ÝQài             #   If it's in the list [0,1,2,3,4,5,6,7,8,9]:
          ï            #    Cast it to an integer to remove any trailing ".0"
                       #    (since dividing always results in a float)
         ë             #   Else:
          ð            #    Push a space character " "
]                      # Close both the if-else clauses and the map
 «                     # Merge the resulting list with the duplicated [0,1,2,3,4,5,6,7,8,9]
  Tô                   # Split the list in parts of size 10
    ε   }              # Map each list to:
     N<                #  Get the map-index + 1
       š               #  And prepend it at the front of the list
         ®I:           # Then replace the "-1" with the input-character
ðý                     # And finally join every inner list by spaces
  »                    # And join the entire string by newlines (which is output implicitly)
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.