माइनस, प्लस, टाइम्स, एक्सप्रेशन?

26

यह एक CMC (चैट मिनी चैलेंज) है जिसे मैंने कुछ समय पहले हमारे चैटरूम, द नाइन्थी बाइट में पोस्ट किया था।

चुनौती

एक सकारात्मक पूर्णांक को देखते हुए x, पिछले 2 बिट्स के आधार पर x, निम्नलिखित करें:

x & 3 == 0: 0
x & 3 == 1: x + x
x & 3 == 2: x * x
x & 3 == 3: x ^ x (exponentiation)

इनपुट आउटपुट

Single Integer -> Single Integer

आउटपुट में एक अनुगामी न्यूलाइन की अनुमति है। किसी अन्य व्हाट्सएप की अनुमति नहीं है।

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

input       output
    1            2
    2            4
    3           27
    4            0
    5           10
    6           36
    7       823543
    8            0
    9           18
   10          100
   11 285311670611
   12            0

यह एक कोड-गोल्फ चुनौती है, इसलिए सबसे छोटा कोड जीतता है!

code-golf  math 
— HyperNeutrino
स्रोत
8
नहीं करना चाहिए 0मामला हो x + 2, के रूप में कैसे दूसरों हैं देखकर x * 2, x ^ 2और x ^^ 2(tetration)? : P
— ETHproductions
हमें सबसे बड़ा आउटपुट क्या होना चाहिए x ^ x? 32-बिट पहले से ही परीक्षण के मामले के लिए पर्याप्त नहीं है 11, और 64-बिट परीक्षण के मामले के लिए पर्याप्त नहीं है 19।
— केविन क्रूज़सेन
@ केविनक्रूजसेन मैं कहूंगा कि आपको केवल उन मामलों को संभालना होगा जहां इनपुट और आउटपुट आपकी भाषा के दायरे में हैं, जब तक कि आपके प्रोग्राम को सैद्धांतिक रूप से अनंत संख्या का आकार दिया जाएगा।
— हाइपरएन्यूट्रीनो
@ हायपरनेटिनो ठीक है, उस स्थिति में मैंने अपना (जावा 7) कोड (
— +72

जवाबों:

13

जेली , 8 बाइट्स

ị“+×*_”v

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

यह काम किस प्रकार करता है

सबसे पहले, नोटिस है कि x&3के बराबर है x%4, जहां %modulo है। फिर, चूंकि जेली मॉड्यूलर इंडेक्सिंग ( a[n] == a[n+len(a)]) का उपयोग करती है , इसलिए हमें उससे निपटने की भी आवश्यकता नहीं है।

फिर:

  • यदि x%4==0, वापसी x_x(घटाव) (स्थिरता के लिए);
  • अगर x%4==1, वापस x+x;
  • यदि x%4==2, वापसी x×x(गुणा);
  • यदि x%4==3, वापसी x*x(प्रतिपादक)

ध्यान दें कि जेली 1-इंडेक्सिंग का उपयोग करती है, इसलिए घटाव "_"को अंत तक ले जाया जाता है।

ị“+×*_”v  example input: 10
ị“+×*_”   index 10 of the string “+×*_”, which gives "×"
       v  evaluate the above as a Jelly expression,
          with 10 as the argument, meaning "10×" is the
          expression evaluated. The dyad "×" takes the
          second argument from the only argument, effectively
          performing the function to itself.
— लीक नन
स्रोत
2
@andrybak AFAIK जेली की अपनी एन्कोडिंग है - यहां देखें , लेकिन मुझे पता है कि इसके सभी पात्र 1 बाइट हैं।
— स्टीफन
"8 बाइट्स"। बाइट्स को कैसे गिना जाना चाहिए? इस उत्तर में आठ वर्ण होते हैं, लेकिन कम से कम एन्कोडिंग स्टैकएक्सचेंज इस पृष्ठ पर कार्य करता है, इसमें 15 बाइट्स (उपयोग किए जाने वाले गिने हुए wc --bytes) लगते हैं ।
— और्रीबक
यदि भाषा इसे एक एन्कोडिंग में व्याख्या करती है, तो बाइट काउंट (imo) के लिए एक और एन्कोडिंग का उपयोग करने का कोई मतलब नहीं है
— मैकेंज़ी मैकक्लेन
@andrybak कोड एक एन्कोडिंग में कूटबद्ध किया गया है ताकि ब्राउज़र इसे सही ढंग से 15 बाइट्स दिखाए। एक एन्कोडिंग में कोड जो जेली समझता है वह 8 बाइट्स है। यदि आप जानना चाहते हैं कि यह कैसे एन्कोड किया गया है, तो github.com/DennisMitchell/jelly/wiki/Code-page पर देखें ।
— Etoplay
9

CJam , 12 बाइट्स

ri__"-+*#"=~

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

व्याख्या

ri            e# Read an int from input (call it x).
  __          e# Duplicate x twice.
    "-+*#"    e# Push this string.
          =   e# Get the character from the string at index x (mod 4).
           ~  e# Eval that char, using the two copies of x from before.

निम्न में से कोई एक कार्य चलाता है जो x's मान 4' (mod 4 AND और 3 के बराबर है) पर निर्भर करता है ।

0:  -  Subtraction
1:  +  Addition
2:  *  Multiplication
3:  #  Exponentiation
— बिजनेस कैट
स्रोत
4

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

.v@"0y*^

दुभाषिया

— आउटग्रॉफर को एरिक करें
स्रोत
हां मैंने इसका परीक्षण किया है और यह काम करता है। और नहीं, मैं vइसके बजाय उपयोग नहीं कर सकता .v।
— निकले हुए एग्रीगेटर
मुझे लगा कि स्कोप लोकल था ... मुझे लगा कि मैं .vएक्सेस नहीं कर सकता Q... जाहिर है कि मैं पर्थ में आउटगोल्फ हो गया। आपके लिए +1।
— लीक नून
@LeakyNun नहीं v, इसमें स्थानीय गुंजाइश है, .vबस एक अभिव्यक्ति है।
— निकले एग्रीकल्चर
मुझे बहुत कुछ सीखना है ...
— लीक नून
3
वह सुंदर है! यह बिल्कुल आश्चर्यजनक है! मुझे पता नहीं था कि यह भी संभव है। शैली बिंदुओं के लिए, "0y*^हो सकता है "-+*^।
— isaacg
3

हास्केल, 28 27 बाइट्स

f x=cycle[0,x+x,x*x,x^x]!!x

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

संपादित करें: 1 बाइट के लिए @ अर्जन जोहान्सन को धन्यवाद।

— nimi
स्रोत
हम्म मुझे बहुत देर हो चुकी है, लेकिन आप इस बाइट को छोटा कर सकते हैं cycle।
— अर्जन जोहानसन
@ NeverrrrJohansen: बेहतर देर से कभी नहीं। धन्यवाद!
— nimi
2

सी, 63 या 62 बाइट्स

#include<math.h>
f(x){return(int[]){0,x+x,x*x,pow(x,x)}[x&3];}

-1 बाइट यदि मैक्रोज़ को अनुमति दी जाती है, तो मान लें xकि यह एक अभिव्यक्ति नहीं है 3+5(क्योंकि इससे पूर्वता गड़बड़ होगी):

#include<math.h>
#define f(x)(int[]){0,x+x,x*x,pow(x,x)}[x&3]
— टिम Čस
स्रोत
@ceilingcat राइट, इसके बारे में भूल गया।
— टिम Timस
MSVS2015 पर संकलन नहीं करता है; Intellisense ने कहा कि cast to incomplete array type "int[]" is not allowedCompiler ने कहा error C4576: a parenthesized type followed by an initializer list is a non-standard explicit type conversion syntax; यह भी! int f (int x) कहां है? कोड वास्तव में कम से कम 8 बाइट्स लंबा है; यह भी बहुत धीमा और अक्षम है, क्योंकि यह हर चीज का मूल्यांकन करता है - न ही इसे दोहराएं IRL)
@ xakepp35 क्या? 1) इसे C कंपाइलर में संकलित करना है। अधिकांश (पढ़ें: सिर्फ सभी लेकिन MSVC के बारे में) C कंपाइलर (int[])इस स्थिति के लिए इस सिंटैक्स का समर्थन करते हैं । 2) f(x)पूरी तरह से कानूनी C89 है। मैंने मानक निर्दिष्ट नहीं किया। 3) यह कोड आकार के बारे में है, दक्षता के बारे में नहीं। और 4) यदि आप संरक्षण करने जा रहे हैं, तो कम से कम एक वास्तविक संकलक का उपयोग करें और / या अपने तथ्यों की जांच करें।
— टिम Timस
@ तैम Čस आह हाँ, रो सॉरी! मैं इसे C ++ कोड के रूप में संकलित करने की कोशिश कर रहा था। यह मेरी गलती है) यह संकलन और महान काम करता है!
2

जावा 7, 75 बाइट्स

long c(int n){int x=n%4;return x<1?0:x<2?n+n:x<3?n*n:(long)Math.pow(n,n);}

भले ही यह नियमों के अनुसार वैध है, long64-बिट है, इसलिए यह 19^19ऊपर और ऊपर के घातांक परीक्षण मामलों के लिए विफल रहता है। यह तय करने के लिए कि हम एक BigDecimalदृष्टिकोण का उपयोग कर सकते हैं :

148 146 बाइट्स

import java.math.*;BigDecimal c(int n){int x=n%4;BigDecimal m=new BigDecimal(n);return x<1?m.subtract(m):x<2?m.add(m):x<3?m.multiply(m):m.pow(n);}

स्पष्टीकरण (BigDecimal दृष्टिकोण का):

import java.math.*;                // Import required for BigDecimal
BigDecimal c(int n){               // Method with integer parameter and BigDecimal return-type
  int x=n%4;                       //  Input modulo-4
  BigDecimal m=new BigDecimal(n);  //  Convert input integer to BigDecimal
  return x<1?                      //  If the input mod-4 is 0:
    m.subtract(m)                  //   Return input - input (shorter than BigDecimal.ZERO)
   :x<2?                           //  Else if the input mod-4 is 1:
    m.add(m)                       //   Return input + input
   :x<3?                           //  Else if the input mod-4 is 2:
    m.multiply(m)                  //   Return input * input
   :                               //  Else:
    m.pow(n);                      //   Return input ^ input
}                                  // End of method

टेस्ट कोड:

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

import java.math.*;
class M{
  static BigDecimal c(int n){int x=n%4;BigDecimal m=new BigDecimal(n);return x<1?m.subtract(m):x<2?m.add(m):x<3?m.multiply(m):m.pow(n);}

  public static void main(String[] a){
    for (int i = 1; i <= 25; i++) {
      System.out.print(c(i) + "; ");
    }
  }
}

आउटपुट:

2; 4; 27; 0; 10; 36; 823543; 0; 18; 100; 285311670611; 0; 26; 196; 437893890380859375; 0; 34; 324; 1978419655660313589123979; 0; 42; 484; 20880467999847912034355032910567; 0; 50;
— केविन क्रूज़सेन
स्रोत
आपको इस तरह से कार्यक्रम को ठीक करने की आवश्यकता नहीं है: यदि संख्या में अनंत आकार थे, तो पी पुराना जवाब काम करेगा; पहला कार्यक्रम मेरे चश्मे के तहत वैध होगा। : पी
— हाइपरनेत्रिनो
@HyperNeutrino तब मैं यह निर्दिष्ट करता हूं कि उत्तर में .. आह, जावा किसी भी तरह से कोड-गोल्फ चुनौतियों को नहीं जीतेगा। ;)
— केविन क्रूज़सेन
1
हां, मैं निर्दिष्ट करूंगा। और हाँ, यह जावा है, यह जीतने वाला नहीं है। : डी
— हाइपरएन्यूट्रीनो
2
" और हाँ, यह जावा है, यह जीतने वाला नहीं है। डी: " मुझे इसकी आदत है। : P यहां तक ​​कि 8 बाइट्स में से मेरा सबसे छोटा जावा उत्तर गोल्फिंग उत्तरों की तुलना में लंबा है। xD हालांकि यह पहली बार था जब मैंने अपने जावा उत्तर के साथ पायथन उत्तर को हराया था, जिसे मुझे लगता है कि कुछ के लिए गणना करना है। ;)
— केविन क्रूज़सेन
2

x86 असेंबलर, इंटेल सिंटैक्स, 192 बाइट्स

.data
f dw @q,@w,@e,@r
.code
mov ecx, eax
and ecx, 3
mov edx,dword ptr f[ecx*4]
call [edx]
ret
q:
xor eax,eax
ret
w:
add eax,eax
ret
e:
mul eax,eax
ret
r:
mov ecx,eax
t:
mul eax,eax
loop t
ret

उदाहरण सबसे तेज काम करने की गति का दिखावा करता है। एक कार्यक्रम या कार्यक्रम का हिस्सा है, जो फास्टकल सम्मेलन का उपयोग करता है। यह xरजिस्टर में इनपुट चर मानता है eax, और रिटर्न परिणाम भी में eax। बुनियादी विचार सशर्त छलांग का उपयोग करने से दूर है, जैसा कि यहां कुछ उदाहरणों में है। इसके अलावा, यह सब कुछ का मूल्यांकन करने के लिए नहीं है (जैसा कि सरणियों के साथ सी उदाहरण में), लेकिन पॉइंटर्स की सरणी का उपयोग फंक्शंस पर करना और एक अनुकूलित "सी भाषा स्विच () - केस .." एनालॉग के रूप में बिना शर्त कूद (जेएमपी / कॉल) करना। यह तकनीक फ़िनिटा ऑटोमेटा के प्रकार में भी उपयोगी हो सकती है - जैसे प्रोसेसर एमुलेटर, एक्ज़ीक्यूटर्स और इतने पर।

अद्यतन: x64 के लिए "नामों" के बजाय "ई" (उदाहरण के raxबजाय eax, ) के rcxबजाय "आर" का उपयोग करें ecx। आकार बदला नहीं जाएगा, और यह 64-बिट अहस्ताक्षरित शब्दों का उपयोग करेगा।

PPCG में आपका स्वागत है! इस चुनौती का उद्देश्य आपके कोड को यथासंभव छोटा बनाना है। इस मामले में, आपके कोड को उन सभी फ़ंक्शन घोषणाओं को मिलाकर आसानी से एक गुच्छा छोटा किया जा सकता है। आप कुछ व्हाट्सएप भी हटा सकते हैं।
— HyperNeutrino
@HyperNeutrino asm ही थोड़े "लंबी" भाषा है :) इसलिए मुझे इस बात का अंदाजा नहीं है कि इसे छोटा कैसे बनाया जाए। किसी भी उदाहरण-सलाह?
एह, क्षमा करें, मुझे इस पोस्ट में आपके C उत्तर पर मेरी टिप्पणी की प्रतिलिपि बनानी चाहिए। मुझे नहीं पता कि एएसएम में कैसे प्रोग्राम करना है लेकिन क्या आप संभावित रूप से कुछ व्हाट्सएप को हटा सकते हैं?
— हाइपरएन्यूट्रीनो
@ हायपरनेट्रिनो, क्षमा करें .. लेकिन ऐसा नहीं लगता है) इसे दूसरों के बीच सबसे लंबा कोड होना चाहिए, मैं बस खिड़कियों के किनारों को लिनक्स प्रारूप में विभाजित कर सकता हूं ताकि 209-> 192 बाइट्स, परिवर्तन दिखाई न दें)
ओ। यह बहुत बुरा है। लेकिन अच्छा प्रस्तुत करने की परवाह किए बिना! :)
— हाइपरएन्यूट्रीनो
2

सी #, 39 बाइट्स

x=>new[]{0,2,x,Math.Pow(x,x-1)}[x&3]*x;

व्याख्या

उसका अवलोकन करो:

(xx, x + x, x * x, x ^ x) == (0, 2, x, x ^ (x-1)) * x

समाधान एक सरणी बनाता है, इसमें अनुक्रमित करता है और फिर परिणाम को गुणा करता है x:

x => new[] { 0, 2, x, Math.Pow(x,x-1) }[x&3] * x;

वैकल्पिक संस्करण:

x=>new[]{0,x+x,x*x,Math.Pow(x,x)}[x%4];

(39B, सरणी में किए गए सभी गुणा, x%4बदल देता है x&3)

x=>x%4<2?x%2*2*x:Math.Pow(x,x%4<3?2:x);

(39B, @ MetaColon के उत्तर के समान है लेकिन इसकी x%2*2*xजगह x*x%4<1?0:2)

— user1655772
स्रोत
1

ओएसिस , 25 बाइट्स

mn4%3Q*nkn4%2Q*nxn4%1Q*++

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

यह काम किस प्रकार करता है

ध्यान दें कि x&3इसके बराबर है x%4, जहां %modulo है।

mn4%3Q*nkn4%2Q*nxn4%1Q*++  input is n
mn4%3Q*                    (n**n)*((n%4)==3)
       nkn4%2Q*            (n**2)*((n%4)==2)
               nxn4%1Q*    (n*2)*((n%4)==1)
                       +   add the above two
                        +  add the above two

ओएसिस एक स्टैक-आधारित भाषा है जहां हर वर्ण एक कमांड है।

— लीक नन
स्रोत
1

सी #, 42 बाइट्स

x=>x%4<2?x*x%4<1?0:2:Math.Pow(x,x%4<3?2:x)

वास्तव में यह सामान्य सी # है, लेकिन जैसा कि आप इसे पूरे कार्यक्रम के रूप में नहीं चला सकते हैं और आपको इसे इंटरेक्टिव में टाइप करना है, मुझे लगता है कि आप इसे सी # इंटरैक्टिव कह सकते हैं ।

स्पष्टीकरण :

x => (x % 4) < 2     //If the bits are smaller than 2 (1 or 0)
? x *           //multiply x with
    (x % 4) < 1 //if the bits are 0
    ? 0         //0 (results in 0)
    : 2         //or else with 2 (results in 2*x or x+x)
: Math.Pow(x,   //otherwise power x by
    (x % 4) < 3 //if the bits are 2
    ? 2         //2 (results in x^2 or x*x)
    : x);       //or else x (results in x^x)

मैं बता नहीं सकता कि यह सबसे छोटा संस्करण है, किसी भी सुझाव की सराहना की जाती है।

— MetaColon
स्रोत
मुझे नहीं लगता कि यह मान्य है। आप आम तौर पर एक कार्यक्रम या समारोह प्रस्तुत करना चाहिए । स्निपेट को डिफ़ॉल्ट रूप से अनुमति नहीं है।
— साइओस
@ यह एक कार्यक्रम है। आपको बस इसे इंटरैक्टिव के माध्यम से चलाना होगा, जो प्रोग्राम की व्याख्या करेगा।
— मेटाकाॅलन
जब मैं इसे इंटरैक्टिव में चलाता हूं, तो मुझे एक त्रुटि मिलती है क्योंकि xपरिभाषित नहीं है। यह एक स्निपेट बनाता है, न कि एक पूर्ण कार्यक्रम।
— साइयो
@Cyoce चुनौती में यह कहा, एक चर x परिभाषित किया जाएगा।
— 19
इसका मतलब यह नहीं है। "एक सकारात्मक पूर्णांक को देखते हुए x" का अर्थ है कि आपको एक मानक इनपुट विधि (यानी, फ़ंक्शन या प्रोग्राम) के माध्यम से दिया जा रहा है x।
— 19
1

सी, 115 बाइट्स

#include<math.h>
#define D(K,L)K(x){return L;}
D(q,0)D(w,x+x)D(e,x*x)D(r,pow(x,x))(*g[])()={q,w,e,r};D(f,g[x%4](x))

उदाहरण एक फ़ंक्शन है int f(int x)

यह सबसे तेज़ काम करने की गति का ढोंग करता है क्योंकि यह सीपीयू को सशर्त कूदने से दूर रखता है। और यह इस कार्य के लिए केवल सही गति-अनुकूलन तरीका है। इसके अलावा, यह सब कुछ का मूल्यांकन नहीं करने की कोशिश करता है, जैसा कि सरणी सी उदाहरण में है, return(int[]){0,x+x,x*x,pow(x,x)}[x%4];लेकिन बुद्धिमानी से पॉइंटर्स की सरणी का उपयोग कार्यात्मक रूप से करने के लिए, बहुत तेज़ पते के अंकगणित (जेएमपी / कॉल) के लिए बहुत तेज़ पते के अंकगणित के साथ, एक अनुकूलित संस्करण के रूप में। स्विच केस.."। यह तकनीक कई प्रकार के फिनिटा ऑटोमेटा में भी उपयोगी हो सकती है - जैसे प्रोसेसर एमुलेटर, एक्ज़क्यूटर्स, कमांड स्ट्रीम पार्सर, और इसी तरह - जहाँ गति मामले और कोड की तरह switch(x%4) case(0):... case(1):... अनुपयुक्त है क्योंकि यह कई cmp / jnz निर्देश पैदा करता है; और ये सीपीयू के लिए महंगे ऑपरेशन हैं

मामले के लिए सबसे सरल और सबसे छोटा परीक्षण कार्यक्रम (डिफ़ॉल्ट स्थितियों में) निम्नानुसार होगा:

D(main,f(x))

यह पेलोड के सिर्फ 12 बाइट्स को जोड़ेगा और हमारे आकार को 127 बाइट्स तक ले जाएगा;

लेकिन आपको लिंकर को fफ़ंक्शन के बजाय प्रवेश बिंदु के रूप में उपयोग करने के लिए बेहतर बताना चाहिए main। यह वह तरीका है, यदि हम इस कार्य के लिए सबसे कम संभव काम करने वाले बाइनरी को कम से कम कोड से प्राप्त करना चाहते हैं ;-) ऐसा इसलिए होता है क्योंकि C लाइब्रेरी आपके मुख्य () फ़ंक्शन को कॉल करने से पहले अतिरिक्त init / शटडाउन कोड जोड़ता है।

कोड बिना किसी ट्रिक्स और मुद्दों के MSVS कम्युनिटी 2015 पर संकलन करता है और सही परिणाम तैयार करता है। मैंने इसे जीसीसी के साथ परीक्षण नहीं किया है, लेकिन मुझे यकीन है कि यह ठीक काम करेगा।

1
PPCG में आपका स्वागत है! इस चुनौती का उद्देश्य आपके कोड को यथासंभव छोटा बनाना है। इस मामले में, आपके कोड को उन सभी फ़ंक्शन घोषणाओं को मिलाकर आसानी से एक गुच्छा छोटा किया जा सकता है। आप कुछ व्हाट्सएप भी हटा सकते हैं।
— HyperNeutrino
मुझे
— इंगित
@RosLuP तु, लेकिन यह अपने 60 बाइट्स संस्करण की तुलना में लगभग दोगुना है। लेकिन यह बहुत तेजी से काम करता है, यह इसके आकार के लायक है।
@ हाइपर न्यूट्रिनो ठीक है। मैंने इसे और संकुचित कर दिया है। लगता है, यह अंतिम संस्करण है! कोई बग नहीं हैं, सभी परीक्षण 8- पास किए गए हैं
@ xakepp35 क्या आपने नापा है कि आप मेरी तुलना में तेज़ हैं?
— रोजलूपी
1

आर, 47 42 बाइट्स

x=scan();c(`-`,`+`,`*`,`^`)[[x%%4+1]](x,x)

समारोह लागू होता है -, +, *, या ^के मापांक के आधार पर xकरने के लिए xऔर x।

-केवल (कुछ) स्मार्ट चीज है, क्योंकि x-xहमेशा 0 होता है।

आर, 33 बाइट्स

pryr::f(c(0,2*x,x^2,x^x)[x%%4+1])

अन्य लोगों के रूप में एक ही विधि का उपयोग करें। हालांकि यह कम है, मुझे यह उतना पसंद नहीं है।

— JAD
स्रोत
0

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

.vjd,+@"-+*^

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

यह काम किस प्रकार करता है

सबसे पहले, नोटिस है कि x&3के बराबर है x%4, जहां %modulo है। फिर, चूंकि पाइथ मॉड्यूलर इंडेक्सिंग ( a[n] == a[n+len(a)]) का उपयोग करता है , इसलिए हमें उससे निपटने की भी आवश्यकता नहीं है।

फिर:

  • यदि x%4==0, वापसी x-x(स्थिरता के लिए);
  • अगर x%4==1, वापस x+x;
  • अगर x%4==2, वापस x*x;
  • अगर x%4==3, वापसी x^x।
.vjd,+@"-+*^  example input: 10
      @"-+*^  "-+*^"[10], which is "*"
     +        "*10"
    ,         ["*10","10"]
  jd          "*10 10"
.v            evaluate as Pyth expression
              (Pyth uses Polish notation)

पोलिश संकेतन के बारे में अधिक जानकारी: विकिपीडिया (यदि आप तुर्की में हैं तो बहुत बुरा है)।

— लीक नन
स्रोत
है ना? यह सिर्फ मुझे बहुत ज्यादा लगता है। विवरण के लिए मेरा उत्तर देखें।
— द एग्री द आउटग्राफर
0

जाप , 13 बाइट्स

Ov"^+*p"gU +U

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

यह प्रोग्राम को छोड़कर -Uकेवल अन्य eval उत्तर के रूप में एक ही विधि का उपयोग करता है U, इसलिए हम ^इसके बजाय (bitwise XOR) का उपयोग करते हैं।

— ETHproductions
स्रोत
0

विम, 50 बाइट्स

y$o^R"A-+*^^V^[0^R"lx0"_Dp^[0D@"kJ0"ad$:r!echo ^R"^R0|bc^<Enter>

यहाँ, कुंजी का प्रतिनिधित्व ^Vकरता है Ctrl+V, ^Rप्रतिनिधित्व करता है Ctrl-Rऔर कुंजी का ^[प्रतिनिधित्व करता हैesc

पहले अभिव्यक्ति का निर्माण करता है और फिर bcउसका मूल्यांकन करने देता है। अन्यथा खाली बफर में पहली पंक्ति पर इनपुट की अपेक्षा करता है।

स्पष्टीकरण:

y$o^R"                                                          Copies the input into register " and pastes it on the second line
      A-+*^^V^[0^R"lx0"_Dp                                      Enters that text after the input on the second line
                          ^[0D@"                                Executes the second line as a Vim command.
                                                                For example, if the input is 12, the second line would be 12A-+*^^[012lx0"_Dp, which means:
                                                                  12A-+*^^[           Insert the text -+*^ 12 times
                                                                           012lx0"_Dp Go 12 chars to the right and remove everything except for that.
                                                                If effect, this basically just selects the appropriate operation.
                                kJ0"ad$                         Put the operator after the number, cut it into register a
                                       :r!                      Execute the following shell command and put the result into the buffer:
                                          echo ^R"^R0|bc<Enter> The shell command "echo [contents of register a][contents of registers 0]|bc. As said above, register a contains the input and the operator, and register 0 contains the input. The <enter> then executes this command.
— Loovjo
स्रोत
जब मैं ^Vइसे टाइप करता हूं, तो मेरे पास क्लिपबोर्ड में बस संख्या के बजाय मेरे पास क्या होता है ...
— लीक
1
इसे ऑनलाइन आज़माएं! इसके अलावा, आप कर सकते हैं Dके बजायd$
— DJMcMayhem
0

अजगर, 9 बाइट्स

@[0yQ*QQ^

परीक्षण सूट

यहां कुछ भी नहीं चल रहा है, बस चार मूल्यों की गणना करें, और मॉड्यूलर इंडेक्सिंग के साथ एक का चयन करें।

@[0yQ*QQ^
@[0yQ*QQ^QQ)Q    Implicit variable introduction
@           Q    Modularly index into the following list
 [0        )     0
   yQ            Q*2
     *QQ         Q*Q
        ^QQ      Q^Q
— isaacg
स्रोत
0

बैच, 135 बाइट्स

@set/an=%1*2^&6
@goto %n%
:6
@set n=1
@for /l %%i in (1,1,%1)do @set/an*=%1
@goto 0
:4
@set n=%1
:2
@set/an*=%1
:0
@echo %n%

मैं [0+...+0, 2+...+2, x+...+x, x*...*x]पिछले दो बिट्स के आधार पर फॉर्म के एक स्ट्रिंग का निर्माण और मूल्यांकन करके घातांक बनाने की उम्मीद कर रहा था , xलेकिन दुर्भाग्य से ऑपरेशन का चयन करने के लिए कोड को व्यक्त करने में बहुत लंबा समय लगा क्योंकि मैं *एक forपैरामीटर के रूप में उपयोग नहीं कर सकता था, लेकिन मैं था कम से कम कुछ बाइट दूर गोल्फ के लिए कुछ गिरावट-हालांकि प्रवंचना का उपयोग करने में सक्षम।

— नील
स्रोत
0

रेटिना , 87 बाइट्स

.+
$*1;$&$*
;((1111)*)(1?)$
;$3$3
1(?=1.*;((1111)*111)$)
$1;
+`\G1(?=.*;(1*))|;1*$
$1
1

इसे ऑनलाइन आज़माएं! (लिंक में परीक्षण सूट शामिल है।)

स्पष्टीकरण: पहली दो लाइनें इनपुट को एकात्मक में परिवर्तित करती हैं और इसे डुप्लिकेट करती हैं (इसलिए अब हमारे पास x;x)। अगले दो लाइनों एक के लिए देखो x&3या तो की 0या 1और परिवर्तन x;xमें x;0या x;2उचित रूप से। अगले दो लाइनों के लिए देखो x&3==3और परिवर्तन x;xमें x;x;x;...;x;1;x( x xरों)। इस का मतलब है कि हम या तो x;0, x;2, x;x, या x;...;xऔर यह गुणा सब कुछ एक साथ और दशमलव के लिए परिवर्तित वापस करने के लिए बनी हुई है। (गुणन कोड रेटिना विकी में उस पर आधारित है लेकिन शून्य से गुणा को संभालने के लिए संशोधित किया गया है।)

— नील
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.