अनन्य और समावेशी श्रेणियों पर उत्पाद


18

से प्रेरित होकर इस सवाल से @ CᴏɴᴏʀO'Bʀɪᴇɴ

प्रश्न से लिया गया:

आपका कार्य सरल है: दिए गए दो पूर्णांक ए और बी, आउटपुट a [ए, बी]; वह है, a और b के बीच की श्रेणी का उत्पाद। आप किसी भी उचित प्रारूप में एक और बी ले सकते हैं, चाहे वह किसी फ़ंक्शन, सूची इनपुट, STDIN, एट वगैरह के तर्क हो। आप किसी भी उचित प्रारूप में आउटपुट कर सकते हैं, जैसे कि रिटर्न वैल्यू (फ़ंक्शंस के लिए) या STDOUT। a हमेशा बी से कम होगा।

ध्यान दें कि अंत अनन्य या बी के समावेशी हो सकता है। मैं मीन मेख निकालने वाला नहीं हूं। ^ _ ^

इस चुनौती का अंतर यह है कि हम रेंज प्रकार के बारे में चुस्त होने वाले हैं। इनपुट प्रपत्र की एक श्रृंखला है [a,b], (a,b], [a,b), या (a,b)जहां एक []एक समावेशी सीमा है और ()एक विशेष सीमा नहीं है। स्पष्ट सीमाओं को देखते हुए, सीमा के उत्पाद प्रदान करते हैं। इसके अलावा इनपुट रेंज में हमेशा कम से कम 1 नंबर शामिल होगा, जिसका अर्थ है कि सीमाएं (3,4)अमान्य हैं और परीक्षण की आवश्यकता नहीं है।

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

[a,b) => result
[2,5) => 24
[5,10) => 15120
[-4,3) => 0
[0,3) => 0
[-4,0) => 24

[a,b] => result
[2,5] => 120
[5,10] => 151200
[-4,3] => 0
[0,3] => 0
[-4,-1] => 24

(a,b] => result
(2,5] => 60
(5,10] => 30240
(-4,3] => 0
(0,3] => 6
(-4,-1] => -6

(a,b) => result
(2,5) => 12
(5,10) => 3024
(-4,3) => 0
(0,3) => 2
(-4,0) => -6

यह एक , इसलिए बाइट्स में सबसे छोटा कार्यक्रम जीत जाता है।


लीडरबोर्ड

इस पोस्ट के निचले हिस्से में स्टैक स्निपेट उत्तर से सूची बनाता है) क) प्रति भाषा में सबसे छोटे समाधान की सूची के रूप में और बी) एक समग्र लीडरबोर्ड के रूप में।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिख रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

## Language Name, N bytes

Nआपके प्रस्तुत करने का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

## Ruby, <s>104</s> <s>101</s> 96 bytes

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फ़ाइलों का योग है या आप दुभाषिया ध्वज दंड को अलग से सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक अंक अंतिम संख्या है:

## Perl, 43 + 2 (-p flag) = 45 bytes

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो बाद में स्निपेट में दिखाई देगा:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

जवाबों:


7

LabVIEW, 38 LabVIEW आदिम

"थोड़ा" संशोधित, अब () और [] के लिए स्कैन करके और संख्याओं में सूचकांक जोड़कर पर्वतमाला निर्धारित करता है।

प्रथम


5
एक ऐसी भाषा होने के लिए जिसे फैंसी gif की आवश्यकता होती है, आपने तुरंत language rep प्राप्त कर लिया है। जीजी। +1
Addison Crump

3

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

lambda s:reduce(int.__mul__,range(*eval(s[1:-1]+'+'+`']'in s`))[s<'[':])

हमारे द्वारा मूल्यांकन किए गए नंबरों को निकालने के लिए s[1:-1], अंत के साथ इनपुट स्ट्रिंग को हटा दिया जाता है, जो एक ट्यूपल देता है। विचार यह है कि rangeइस गुच्छे को प्राप्त करें और उत्पाद लें।

lambda s:reduce(int.__mul__,range(*eval(s[1:-1]))

फ़्यूडिंग समापन बिंदुओं को समायोजित करने के लिए होता है। ऊपरी समापन बिंदु आसान है, बस पहले तत्व को काट दें यदि इनपुट शुरू होता है (, जैसा कि किया जाता है [s<'[':]

अन्य समापन बिंदु पेचीदा है। पायथन के पास सूची के अंतिम तत्व को सशर्त रूप से हटाने का एक साफ तरीका नहीं है क्योंकि l[:0]पूरी चीज को हटा देता है। तो, हम कुछ अजीब करते हैं। हम टपल स्ट्रिंग को संशोधित करने से पहले इसे स्ट्रिंग पर कील के लिए मूल्यांकन किया जाता है "+True"या "+False"में है कि क्या रों समाप्त होता है पर निर्भर करता है ]या )। नतीजा यह होता है कि कुछ ऐसा 3,7हो जाता है 3,7+Falseजो या तो है 3,7, या 3,7+Trueजो है 3,8

वैकल्पिक, प्रिटियर 72:

lambda s:eval("reduce(int.__mul__,range((s<'[')+%s+(']'in s)))"%s[1:-1])

3

Minecraft 15w35a +, कार्यक्रम का आकार 638 कुल (नीचे देखें)

यहाँ मेरे जवाब के रूप में ही , लेकिन संशोधित। चूंकि Minecraft में कोई स्ट्रिंग इनपुट नहीं है, इसलिए मैंने स्कोरबोर्ड इनपुट रखने की स्वतंत्रता ली। यदि वह समस्या है, तो इस उत्तर को गैर-प्रतिस्पर्धी मानें।

यहाँ छवि विवरण दर्ज करें

यह PI a,bदो लीवर द्वारा निर्दिष्ट समावेशी / अनन्य के साथ गणना करता है। यहाँ छवि विवरण दर्ज करेंइन दोनों आदेशों का उपयोग करके इनपुट दिया गया है: /scoreboard players set A A {num}और /scoreboard players set B A {num}। उपयोग करने के लिए याद रखें/scoreboard objectives add A dummyइनपुट से पहले ।

उपयोग करके स्कोर किया गया: {program size} + ( 2 * {input command} ) + {scoreboard command} = 538 + ( 2 * 33 ) + 34 = 638 :।

यह कोड निम्नलिखित psuedocode से मेल खाता है:

R = 1
T = A
loop:
  R *= A
  A += 1
  if A == B:
    if A.exclusive:
      R /= T
    if B.exclusive:
      R /= B
    print R
    end program

यहाँ दुनिया डाउनलोड करें


2

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

*FPW}\)ztW}\(z}FvtPz

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

स्पष्टीकरण:

*FPW}\)ztW}\(z}FvtPz   implicit: z = input string
                 tPz   remove the first and last character of z
                v      evaluate, returns a tuple of numbers
              }F       inclusive range
        tW             remove the first number, if
          }\(z            "(" in z
  PW                   remove the last number, if
    }\)z                  ")" in z
*F                     compute the product of the remaining numbers

2

रूबी, 79 77 बाइट्स

->s{a,b=s.scan /\-?\d+/;(a.to_i+(s[?[]?0:1)..b.to_i-(s[?]]?0:1)).reduce 1,:*}

79 बाइट्स

->s{a,b=s.scan(/\-?\d+/).map &:to_i;((s[?[]?a:a+1)..(s[?]]?b:b-1)).reduce 1,:*}

Ungolfed:

-> s {
  a,b=s.scan /\-?\d+/    # Extracts integers from the input string, s
  (
    a.to_i+(s[?[]?0:1).. # Increase start of the range by 1 if s contains `(`
    b.to_i-(s[?]]?0:1)   # Decrease end of the range by 1 if s contains `)`
  ).reduce 1,:*
}

उपयोग:

->s{a,b=s.scan /\-?\d+/;(a.to_i+(s[?[]?0:1)..b.to_i-(s[?]]?0:1)).reduce 1,:*}["(2,5]"]
=> 60

2

गंभीरता से, 31 बाइट्स

,#d@p@',@s`εj≈`Mi(@)']=+)'(=+xπ

एक स्ट्रिंग के रूप में इनपुट लेता है (डबल कोट्स में लिपटा)

इसे ऑनलाइन आज़माएं (इनपुट मैन्युअल रूप से दर्ज किया जाना चाहिए)

स्पष्टीकरण:

,#d@p@                             get input, take first and last character off and push them individually
      ',@s`εj≈`Mi                  split on commas, map: join on empty, cast to int; explode list
                 (@)']=+)'(=+      increment start and end if braces are ( and ] respectively (since range does [a,b))
                             xπ    make range, push product

1

पायथन 3, 104

y,r=input().split(',')
t=int(y[1:])+(y[0]<')')
for x in range(t+1,int(r[:-1])+(r[-1]>'[')):t*=x
print(t)

स्टड से इनपुट लेता है।


हमने वास्तव में एक ही दूसरे Oo
Eumel

@Eumel जो बिल्ला होना चाहिए।
मॉर्गन थ्रैप

बीमार वास्तव में मेटा पर अभी पोस्ट ^ ^
Eumel

@Eumel: वास्तव में आपने अपना दूसरा पोस्ट मॉर्गन थ्रैप से पहले किया था
ev3commander

क्या सचमे? यह दोनों उत्तरों पर n सेकंड पहले दिखाया गया है
Eumel

1

MATLAB, 86 70 बाइट्स

s=sscanf(input(''),'%c%d,%d%c');a=s<42;disp(prod(a(1)+s(2):s(3)-a(4)))

यह ऑक्टेव के साथ भी काम करता है । आप यहाँ ऑनलाइन कोशिश कर सकते हैं । मैंने उस कार्यक्षेत्र में एक स्क्रिप्ट के रूप में कोड जोड़ा है, इसलिए आप बस productRangeप्रॉम्प्ट पर दर्ज कर सकते हैं , फिर अपना इनपुट दर्ज कर सकते हैं, जैसे '(2,5]'


तो कोड पहले कोष्ठक और संख्याओं को एक साथ निकालने के लिए इनपुट को स्कैन करता है:

s=sscanf(input(''),'%c%d,%d%c');

यह एक एरे देता है जो बनता है [bracket, number, number, bracket]

सरणी की तुलना 42, वास्तव में 42 और 90 के बीच की किसी भी संख्या के साथ की जाएगी। यह निर्धारित करता है कि यह किस प्रकार का ब्रैकेट था, 1 दे रहा था यदि यह एक विशेष ब्रैकेट है, और 0 अगर एक समावेशी ब्रैकेट है।

a=s<42;

अंत में, हम आवश्यक रेंज के उत्पाद प्रदर्शित करते हैं:

disp(prod(a(1)+s(2):s(3)-a(4)))

उत्पाद पहले नंबर के साथ घूरने वाली संख्याओं का है s(2)और पहला ब्रैकेट प्रकार a(1)(जो कि एक 1 है, तो एक विशेष ब्रैकेट है), दूसरे नंबर तक s(3)और दूसरे ब्रैकेट प्रकार को शामिल करते हुए a(4)। यह सही समावेशी / अनन्य सीमा देता है।


1

जूलिया, 75 बाइट्स

s->prod((x=map(parse,split(s[2:end-1],",")))[1]+(s[1]<41):x[2]-(s[end]<42))

यह एक अनाम फ़ंक्शन है जो एक स्ट्रिंग को स्वीकार करता है और एक पूर्णांक देता है। इसे कॉल करने के लिए, इसे एक नाम दें, उदा f=s->...

Ungolfed:

function f(s::AbstractString)
    # Extract the numbers in the input
    x = map(parse, split(s[2:end-1], ","))

    # Construct a range, incrementing or decrementing the endpoints
    # based on the ASCII value of the surrounding bracket
    r = x[1]+(s[1] == 40):x[2]-(s[end] == 41)

    # Return the product over the range
    return prod(r)
end

1

गणितज्ञ, 128 बाइट्स

1##&@@Range[(t=ToExpression)[""<>Rest@#]+Boole[#[[1]]=="("],t[""<>Most@#2]-Boole[Last@#2==")"]]&@@Characters/@#~StringSplit~","&

यह बहुत लंबा है ... वर्तमान में StringReplace+ RegularExpressionसमाधान के बारे में सोच रहा है ।


0

पॉवरशेल, 146 104 बाइट्स

param($i)$a,$b=$i.trim("[]()")-split',';($a,(1+$a))[$i[0]-eq'(']..($b,(+$b-1))[$i[-1]-eq')']-join'*'|iex

42 बाइट्स को गोल्फ से बदलकर बताया जाता है कि इनपुट से नंबर कैसे निकाले जाते हैं। वू!

param($i)                          # Takes input string as $i
$a,$b=$i.trim("[]()")-split','     # Trims the []() off $i, splits on comma,
                                   # stores the left in $a and the right in $b

($a,(1+$a))[$i[0]-eq'(']..($b,(+$b-1))[$i[-1]-eq')']-join'*'|iex
# Index into a dynamic array of either $a or $a+1 depending upon if the first
# character of our input string is a ( or not
# .. ranges that together with
# The same thing applied to $b, depending if the last character is ) or not
# Then that's joined with asterisks before
# Being executed (i.e., eval'd)


0

पर्ल 6 , 60 बाइट्स

{s/\((\-?\d+)/[$0^/;s/(\-?\d+)\)/^$0]/;s/\,/../;[*] EVAL $_}

मिस-मैच का एक सा कारण है क्योंकि आप जिस तरह (2,5]से पर्ल 6 में उदाहरण लिखेंगे 2^..5(वह [2^..5]भी काम करेगा)।
इसलिए मैं स्वैप करने के लिए है (2के साथ [2^, और ,साथ .., तो मैं करने के लिए है EVALएक रेंज में।


उपयोग:

# give it a name
my &code = {...}

# the `$ =` is so that it gets a scalar instead of a constant

say code $ = '(2,5)'; # 12
say code $ = '[2,5)'; # 24
say code $ = '(2,5]'; # 60
say code $ = '[2,5]'; # 120

say code $ = '(-4,0)' # -6
say code $ = '[-4,0)' # 24
say code $ = '(-4,0]' # 0
say code $ = '[-4,0]' # 0

say code $ = '(-4,-1)' # 6
say code $ = '[-4,-1)' # -24
say code $ = '(-4,-1]' # -6
say code $ = '[-4,-1]' # 24

# this is perfectly cromulent,
# as it returns the identity of `*`
say code $ = '(3,4)'; # 1

0

CJam, 34 बाइट्स

r)\(@+"[()]"2/\.#\',/:i.+~1$-,f+:*

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

स्पष्टीकरण:

r       Read input.
)       Split off last character.
\       Swap rest of input to top.
(       Split off first character.
@       Rotate last character to top.
+       Concatenate first and last character, which are the two braces.
"[()]"  Push string with all possible braces.
2/      Split it into start and end braces.
\       Swap braces from input to top.
.#      Apply find operator to vector elements, getting the position of each brace
        from input in corresponding list of possible braces. The lists of braces
        are ordered so that the position of each can be used as an offset for the
        start/end value of the interval.
\       Swap remaining input, which is a string with two numbers separated by
        a comma, to top.
',/     Split it at comma.
:i      Convert the two values from string to integer.
.+      Element-wise addition to add the offsets based on the brace types.
~       Unwrap the final start/end values for the interval.
1$      Copy start value to top.
-       Subtract it from end value.
,       Build 0-based list of values with correct length.
f+      Add the start value to all values.
:*      Reduce with multiplication.

0

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

s=>eval(`for(n=s.match(/-*\\d+/g),i=n[0],c=s[0]<"["||i;++i<+n[1]+(s.slice(-1)>")");)c*=i`)

व्याख्या

s=>
  eval(`                    // use eval to allow for loop without return or {}
    for(
      n=s.match(/-*\\d+/g), // n = array of input numbers [ a, b ]
      i=n[0],               // i = current number to multiply the result by
      c=s[0]<"["||i;        // c = result, initialise to a if inclusive else 1
      ++i<+n[1]             // iterate from a to b
        +(s.slice(-1)>")"); // if the end is inclusive, increment 1 more time
    )
      c*=i                  // multiply result
  `)                        // implicit: return c

परीक्षा


0

आर, 102 104 बाइट्स

f=function(s){x=scan(t=gsub('\\(|\\[|,|\\)|\\]',' ',s))+c(grepl('^\\(',s),-(grepl('\\)$',s)));prod(x[1]:x[2])}

Ungolfed

f=function(s){
    # remove delimiting punctuation from input string, parse and return an atomic vector
    x=scan(t=gsub('\\(|\\[|,|\\)|\\]',' ',s)) +
    # add /subtract from the range dependent on the `[)` pre/suf-fixes
    c(grepl('^\\(',s),-(grepl('\\)$',s)))
    # get the product of the appropriate range of numbers
    prod(x[1]:x[2])
}

नकारात्मक संख्याओं की अनुमति देने के लिए संपादन करें [2 और पात्रों की कीमत पर


भाषा?
ThisSuitIsBlackNot

@ThisSuitIsBlackNot - R(और उत्तर में तय किया गया है)
mnel

0

जावास्क्रिप्ट (ईएस 6), 79

एक अनाम विधि के रूप में

r=>eval("[a,b,e]=r.match(/-?\\d+|.$/g);c=a-=-(r<'@');for(b-=e<'@';a++<b;)c*=a")

टेस्ट स्निपेट

F=r=>eval("[a,b,e]=r.match(/-?\\d+|.$/g);c=a-=-(r<'@');for(b-=e<'@';a++<b;)c*=a")

// TEST
console.log=x=>O.innerHTML+=x+'\n'

;[
 ['[2,5)',24],['[5,10)',15120],['[-4,3)',0],['[0,3)',0],['[-4,0)',24],
 ['[2,5]',120],['[5,10]',151200],['[-4,3]',0],['[0,3]',0],['[-4,-1]',24],
 ['(2,5]',60],['(5,10]',30240],['(-4,3]',0],['(0,3]',6],['(-4,-1]',-6],
 ['(2,5)',12],['(5,10)',3024],['(-4,3)',0],['(0,3)',2],['(-4,0)',-6]
].forEach(t=>{
  r=F(t[0]),k=t[1],console.log(t[0]+' -> '+r+' (check '+k+ (k==r?' ok)':' fail)'))
})
<pre id=O></pre>

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