मुझे बताएं कि मुझे कितनी गणित की समस्याएं हैं!

36

मेरे शिक्षक हमेशा मुझे होमवर्क के लिए गणित की समस्याओं का सबसे जटिल सेट देते हैं। जैसा: pg. 546: 17-19, 22, 26, pg. 548: 35-67 odd, 79, 80-86 even। और मैं पहले से ही जानना चाहता हूं कि मेरे होमवर्क के लिए कितना समय निर्धारित करना है, लेकिन मैं यह सब नहीं करना चाहता। इसीलिए आपका काम यह है कि वह मेरे लिए यह कार्यक्रम बनाए।

विशेष विवरण

  • आपको उन समस्याओं का विस्तार करने के लिए एक स्ट्रिंग मिलेगी, जिन्हें मुझे args, stdio, आदि के रूप में पूरा करना है।
  • वे अल्पविराम से अलग हो जाएंगे (संभवतः comma-spaceअलग हो जाएंगे)
  • इसमें सिर्फ एक संख्या (जैसे 79) के रूप में एकल समस्याएं शामिल होंगी
  • और फार्म में पर्वतमाला 17-18(फिर से, आपको वैकल्पिक स्थानों से निपटना होगा)
  • पर्वतमाला दोनों सिरों के समावेशी हैं
  • पर्वतमाला वैकल्पिक रूप से प्रत्यय हो जाएगा oddया even, आप को ध्यान में रखना है जो।
  • पर्वतमाला / पृष्ठों का एक सेट फॉर्म में एक पृष्ठ संख्या द्वारा पूर्व निर्धारित किया जाएगा pg. 545:, फिर से वैकल्पिक स्थानों से निपटने के लिए होगा। आप सुरक्षित रूप से इनकी उपेक्षा कर सकते हैं, क्योंकि आपको सभी पृष्ठों पर समस्याओं को प्राप्त करने की आवश्यकता है
  • पाठ अपरकेस या लोअरकेस में हो सकता है, लेकिन दोनों नहीं होगा।
  • वापसी, स्टडआउट, आदि समस्याओं की संख्या जो मुझे होमवर्क के लिए करना है।
  • चूंकि यह कोड-गोल्फ है , बाइट्स जीत में सबसे छोटा कोड!

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

pg. 546: 17-19, 22, 26, pg. 548: 35-67 odd, 79, 80-86 even   ->    27
pg. 34: 1                                                    ->    1
PG. 565: 2-5,PG.345:7                                        ->    5
pg. 343: 5,8,13 - 56 even,pg. 345: 34 - 78,80                ->    70
pg.492: 2-4 odd,7-9 even                                     ->    2
code-golf  natural-language 
— Maltysen
स्रोत
12
क्या प्रोफेसर आपको कुछ दे सकते हैं 2-4 odd? यह सरल दृष्टिकोण के लिए कुछ समस्याओं का कारण प्रतीत होता है।
— ब्योर्न लिंडकविस्ट
1
^ मुझे लगता है कि यह वर्तमान समस्या बयान के अनुसार, एक परीक्षण मामला होना चाहिए।
— mbomb007
2
यह परीक्षण मामला होना चाहिए:pg.492: 2-4 odd,7-9 even -> 2
— mbomb007
2
क्या सीमाएं ओवरलैप हो सकती हैं? जैसे 22-26,25-30?
— रेटो कोराडी
1
@RetoKoradi नं।
— माल्टसेन

जवाबों:

15

सीजाम, 61 58 51 48 46 43 41 38 बाइट्स

leuS-',/{':/W>:~_2*2<~z),>1f&\,5--~}%,

CJam दुभाषिया में परीक्षण मामलों की जाँच करें ।

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

leuS-      e# Read a line from STDIN, convert to uppercase and remove spaces.
',/        e# Split at commas.
{          e# For each chunk:
  ':/W>    e#   Split at colons and only keep the last chunk.
  :~       e#   Evaluate the string inside the array.
  _2*      e#   Copy the array, repeated twice.
  2<       e#   Keep only the first two elements.

           e#   In all possible cases, the array now contains exactly two
           e#   integers, which are equal in case of a single problem.

  ~        e#   Dump the array on the stack.
  z),      e#   Push [0 ... -N], where N is the second integer.
  >        e#   Discard the first M elements, where M is the first integer.
  1f&      e#   Replace each element by its parity.
  \,       e#   Push L, the length of the original array.

           e#   EVEN and ODD all push elements, so L is 1 for single problems,
           e#   2 for simple ranges, 5 for odd ranges and 6 for even ranges.

  5--      e#   Discard all elements equal to L - 5 from the array of parities.

           e#   This removes 0's for odd ranges, 1's for even ranges, -3's for
           e#   other ranges and -4's for single problems, thus counting only
           e#   problems of the desired parities.

  ~        e#   Dump the resulting array on the stack.
}%         e# Collect the results in an array.
,          e# Compute its length.
— डेनिस
स्रोत
क्या यह नवीनतम परीक्षण मामले के साथ काम करता है?
— mbomb007
ऐसा होता है। मैंने नवीनतम परीक्षण मामले को लिंक में जोड़ा है।
— डेनिस
10

पर्ल - 47 बाइट्स

#!perl -p054
{map$\+=($_%2x9^lc$')!~T,$&..$'*/\d+ ?-/}}{

नए परीक्षण मामले को पारित करने के लिए संशोधित।

मूल

पर्ल - 36 बाइट्स

#!perl -p054
$\+=/\d+ ?-/*($'-$&>>/o|e/i)+1}{

शेबंग को 4 के रूप में गिना जाता है, स्टड से इनपुट लिया जाता है।

नमूना उपयोग

$ echo pg. 546: 17-19, 22, 26, pg. 548: 35-67 odd, 79, 80-86 even | perl math-problems.pl
27

$ echo pg. 34: 1 | perl math-problems.pl
1

$ echo PG. 565: 2-5,PG.345:7 | perl math-problems.pl
5

$ echo pg. 343: 5,8,13 - 56 even,pg. 345: 34 - 78,80 | perl math-problems.pl
70

चेतावनियां

सम / विषम श्रेणियों के लिए, यह अपेक्षित है कि कम से कम एक समापन बिंदु सीमा की समता से मेल खाता हो। उदाहरण के लिए, 11-19 odd, 11-20 odd, और 10-19 oddसब सही ढंग से 5 रूप में गिना जाएगा, लेकिन 10-20 odd6 के रूप में पदभार बार गणना हो जाएगा।

— Primo
स्रोत
यह कैसे काम करता है pg. 20: 13-15 even? या pg. 20: 13-14 even?
— चार्ल्स
1
*एक चरित्र से भी छोटा है &&, एक आसान सुधार के लिए:$\+=/\d+ ?-/*($'-$&>>/o|e/i)+1for@F}{
— ग्रैमी
1
यार, यह चतुर है! जब तक मैं कुछ याद नहीं कर रहा हूं, आपको समाप्त करने में सक्षम होना चाहिए lc=~।
— डेनिस
1
मुझे वह T^हिस्सा मिल गया , लेकिन किसी तरह छूट lcगया जिसने मामले को बदल दिया $'। Prepending lcके लिए $'होगा थोड़ा कम किया गया है। यह अभी भी दृष्टिकोण के लिए काम करना चाहिए: lc$'!~(T^lc$_%2)या($_%2x9^lc$')!~T
— डेनिस
1
@ पिछले संस्करण के लिए डेनिस, इसमें कोष्ठकों की आवश्यकता होगी। !~Tहालांकि प्रतिभाशाली है, धन्यवाद!
— प्रिमो
6

पायथन 2, 259 253 249 239 बाइट्स

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

यह शायद अभी भी अधिक गोल्फ हो सकता है।

संपादित करें: एक बग फिक्स्ड है जिसके कारण मेरा काम नहीं हुआ 2-4 even जैसा कि मैंने उम्मीद की थी। फिर उस फिक्स के लिए एक समायोजन किया। उस फिक्स ने मुझे चार बाइट्स बचाए!

संपादित करें: अब दो उद्धरण चिह्नों के लिए उपयोग input()और +2 बाइट्स के साथ उपयोगकर्ता को इनपुट को घेरना चाहिए।

import re
c=0
for x in re.sub(r'..\..*?:','',input()).replace(' ','').split(','):
 y=x.split('-')
 if len(y)<2:c+=1
 else:
    a,b=y[0],y[1];d=int(re.sub('[A-z]','',b))-int(a)+1
    if b[-1]>':':d=d/2+d%2*(int(a)%2==ord(b[-3])%2)
    c+=d
print c

कम गोल्फ वाला (टिप्पणियों के साथ!: D):

मुझे उम्मीद है कि इन टिप्पणियों से कुछ मदद मिलेगी। मुझे अभी भी पूरा यकीन नहीं है अगर मैंने समझाया कि आखिरी जटिल रेखा सही है या नहीं।

import re
def f(s):
    c=0
    l=re.sub(r'..\..*?:','',s).replace(' ','').split(',')   # remove pg #'s and split
    for x in l:
        y=x.split('-')
        if len(y)<2:                                # if not a range of numbers
            c+=1
        else:
            a,b=y[0],y[1]                           # first and second numbers in range
            d=int(re.sub('[A-z]','',b))-int(a)+1    # number of pages
            if b[-1]>':':                           # if last character is not a digit
                # half the range
                # plus 1 if odd # of pages, but only if first and last numbers in the range
                #       are the same parity
                # ord(b[-3])%2 is 0 for even (v), 1 for odd (o)
                d=d/2+(d%2)*(int(a)%2==ord(b[-3])%2)
            c+=d
    print c
— mbomb007
स्रोत
2
बस एक छोटी सी बात है, चूंकि आप पायथन 2 का उपयोग कर रहे हैं, आप अलग-अलग संकेत के रूप में रिक्त स्थान और टैब (1 बाइट प्रत्येक) का उपयोग कर सकते हैं। प्रासंगिक टिप
— FryAmTheEggman
यह भी पाया गया कि मैंने पहली बार में गलत गणना की थी। संपादकों से कॉपी किए गए टैब उन्हें रिक्त स्थान में परिवर्तित करते हैं।
— mbomb007
आप s=raw_input()कुछ इंडेंटेशन कर और हटाकर कम से कम 4 बाइट्स बचा सकते हैं ।
4

पायथ, 43 42 44 42 बाइट्स

lsm-%R2}hKvMc-ecd\:G\-eK?}\ed}edGYc-rzZd\,

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

मुझे लगता है कि मैं अभी भी एक या दो बाइट्स काट सकता हूं।

व्याख्या

lsm-%R2}hKvMc-ecd\:G\-eK?}\ed}edGYc-rzZd\,  implicit: z = input string
                                    rzZ     convert z to lower-case
                                   -   d    remove all spaces from z
                                  c     \,  and split by ","
  m                                         map each part d to:
               cd\:                           split d by ":"
              e                               and only use the last part (removes page number)
             -     G                          remove all letters (removes odd/even)
            c       \-                        split by "-"
          vM                                  and evaluate all (one or two) numbers
         K                                    and store the result in K
       }hK            eK                      create the list [K[0], K[0]+1, ..., K[-1]]
    %R2                                       apply modulo 2 to each element
   -                                          and remove:
                         }\ed                   "e" in d (1 for in, 0 for not in)
                        ?    }edG               if d[-1] in "abcde...z" else
                                 Y              dummy value
 s                                            combine all the lists
l                                             print the length
— Jakube
स्रोत
क्या यह नवीनतम परीक्षण मामले के साथ काम करता है?
— mbomb007
@ mbomb007: यह करता है।
— डेनिस
3

जावास्क्रिप्ट (Spidermonkey कंसोल) - 139

कमांड लाइन पर परीक्षण करना आसान है।

for(r=/[:,] *(\d+)[- ]*(\d+)? *(o|e)?/gi,m=readline(z=0);f=r.exec(m);z+=!b||((p=b-a)%2||!c|a%2^/e/i.test(c))+p/(2-!c)|0)[,a,b,c]=f
print(z)

Ungolfed:

// any number set after "pg:" or a comma
// \1 is FROM, \2 is TO, \3 is odd/even 
r=/[:,] *(\d+)[- ]*(\d+)? *(o|e)?/gi;
m=readline();
z=0; // this is the sum.
while(f=r.exec(m)){
    [,from,to,oddEven]=f;
    if(!to) {
        z++;
    } else {
        if((to-from)%2) {
            // if to and from are not the same parity, add 1
            z++;
        } else {
            // if to and from are not the same parity...
            if(!oddEven) {
                // and we don't have a parity marker, add one
                z++;
            } else if(a%2 != /e/i.test(c)) {
                // if we do have a parity marker,
                // AND the parity of from and to matches the 
                // parity of the oddEven sign, then add 1
                z++;
            }
        }
        // then add the difference between to-from and
        // if oddEven exists, divide by two and round down
        z+=(to-from)/(oddEven?2:1)|0;
    }

}
print(z);
— चार्ल्स नहीं
स्रोत
क्या [,from,to]बस हो सकता है [from,to]?
— यति
1
@TuukkaX नहीं क्योंकि वह उस सरणी का पहला मान छोड़ना है r.exec, जिसमें संपूर्ण मिलान स्ट्रिंग है।
— पैट्रिक रॉबर्ट्स
3

कारक - 488 बाइट्स:

USING: arrays ascii kernel math math.parser math.ranges pcre sequences ;
IN: examples.golf.homework

: c ( a -- b )
    >lower "(?:[,:]|^) *(\\d+) *(?:- *(\\d+) *(e|o)?)?" findall [
        rest [ second dup string>number swap or ] map
        dup length 1 = [ drop 1 ] [
            dup length 2 = [ first2 swap - 1 + ] [
                first3 "o" = [ [a,b] [ odd? ] count ] [
                    [a,b] [ even? ] count
                ] if
            ] if
        ] if
    ] map sum ;
— ब्योर्न लिंडक्विस्ट
स्रोत
2

बैश 344 315 306 294 262 252 242 240

IFS=,
o(){ R=0;for ((i=$1;i<=$2;R+=i++%2));do :
done
}
e(){ q=$R;o $*;((R=q-R))
}
for c in ${1,,};do
c=${c#*:}
m=${c##* }
l=${c%-*}
l=${l// }
h=${c#*-}
[[ a< $m ]]&&h=${h% *}
h=${h// }
((R=h-l+1))
eval "${m::1} $l $h"
((t+=R))
done;echo $t

मुझे नहीं लगता कि मैंने इसे जितना संभव हो उतना गॉकेट किया है, लेकिन पहले प्रस्तुत करने के लिए बुरा नहीं है। नीचे टिप्पणी संस्करण।

IFS=, # Setup IFS for the for loops, We want to be able to split on commas

o(){ # Odd
    R=0  # Reset the R variable

    # Increments R for each odd element in the range
    # $1-$2 inclusive
    for ((i=$1;i<=$2;R+=i++%2));do
        : # Noop command
    done
}

e(){ # Even
    # Save R, it contains the total number of elements between low
    # and high
    q=$R
    # Call Odd, This will set R
    o $*
    # Set R = total number of elements in sequence - number of odd elements.
    ((R=q-R))
}

# This lowercases the firs arg. IFS causes it to split on commas.
for c in ${1,,};do
    c=${c#*:}  # Strips the page prefix if it exists
    m=${c##* }  # Capture the odd/even suffix if it exists
    l=${c%-*}  # Capture low end of a range, Strips hyphen and anything after it
    l=${l// }  # Strips spaces
    h=${c#*-}  # Capture high end of a range, Strips up to and including hyphen

    # If we have captured odd/even in m this will trigger and strip
    # it from the high range variable.
    [[ a< $m ]]&&h=${h% *}
    h=${h// }  # Strip Spaces

    # Give R a value.
    # If we are in a range it will be the number of elements in that range.
    # If we arent l and h will be equal are R will be 1
    ((R=h-l+1))

    # Call the odd or even functions if we captured one of them in m.
    # If we didnt m will contain a number and this will cause a warning
    # to stderr but it still works.
    eval "${m::1} $l $h"

    # Add R to total
    ((t+=R))
done

# Print result
echo $t

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

bash math.sh "pg. 546: 17-19, 22, 26, pg. 548: 35-67 odd, 79, 80-86 even"
bash math.sh "pg. 34: 1"
bash math.sh "PG. 565: 2-5,PG.345:7"
bash math.sh "pg. 343: 5,8,13 - 56 even,pg. 345: 34 - 78,80"
bash math.sh "pg.492: 2-4 odd,7-9 even"

इस बात पर निर्भर करता है कि मैंने नियमों को कैसे पढ़ा, यह एक और 4 बाइट्स को बचाने के लिए संभव हो सकता है। यहां तक ​​कि अगर / विषम हमेशा लोअरकेस है तो ${1,,}इसे बदला जा सकता है$1

— डैनियल वेकफील्ड
स्रोत
क्या यह नवीनतम परीक्षण मामले के साथ काम करता है?
— mbomb007
बस यह परीक्षण किया और हाँ यह करता है।
— डैनियल वेकफील्ड
1

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

परीक्षण करने के लिए फ़ायरफ़ॉक्स में स्निपेट चलाएँ

F=s=>s.replace(/([-,.:]) *(\d+) *(o?)(e?)/ig,(_,c,v,o,e)=>
  c=='-'?(t+=1+(o?(v-(r|1))>>1:e?(v-(-~r&~1))>>1:v-r),r=0)
  :c!='.'&&(t+=!!r,r=v)
,r=t=0)&&t+!!r

// Less golfed

U=s=>{
  var r = 0, // value, maybe range start
  t = 0; // total
  s.replace(/([-,.:]) *(\d+) *(o?)(e?)/ig, // execute function for each match
    (_ // full match, not used
     , c // separator char, match -:,.
     , v // numeric value
     , o // match first letter of ODD if present
     , e // match first letter of EVEN if present
    )=>
    {
      if (c == '-') // range end
      {
        t++; // in general, count range values as end - start + 1
        if (o) // found 'odd'
        {
          r = r | 1; // if range start is even, increment to next odd
          t += (v-r)>>1; // end - start / 2
        }
        else if (e) // found 'even'
        {
          r = (r+1) & ~1; // if range start is odd, increment to next even
          t += (v-r)>>1; // end - start / 2
        }
        else
        {
          t += v-r; // end - start
        }
        r = 0; // range start value was used
      }
      else if (c != '.') // ignore page numbers starting with '.'
      { 
        // if a range start was already saved, then it was a single value, count it
        if (r != 0) ++t;
        r = v; // save value as it counld be a range start
      }
    }
  )            
  if (r != 0) ++t; // unused, pending range start, was a single value
  return t
}

// TEST

out=x=>O.innerHTML+=x+'\n';

test=["pg. 546: 17-19, 22, 26, pg. 548: 35-67 odd, 79, 80-86 even",
"pg. 34: 1", "PG. 565: 2-5,PG.345:7",
"pg. 343: 5,8,13 - 56 even,pg. 345: 34 - 78,80"];

test.forEach(t=>out(t + ' --> ' + F(t)))
<pre id=O></pre>
स्निपेट का विस्तार करें

— edc65
स्रोत
1

सी ++ 226 224 222

मुझे पता है कि मैं पार्टी के लिए देर से आया हूं, लेकिन यह एक मजेदार समस्या थी और सी-पारिवारिक भाषाओं का उपयोग करने वाली प्रविष्टियों की कमी ने मुझे परेशान किया।

तो यहाँ एक C ++ फ़ंक्शन है जिसमें कोई regexp या स्ट्रिंग प्रतिस्थापन नहीं है, बस कुछ सरल गणित:

void f(){char c;int o=0,i,j;while(cin>>c)c=='p'||c==80?cin.ignore(9,58):cin.unget(),cin>>i>>c&&c==45?cin>>j>>c&&(c=='e'||c=='o')?cin.ignore(9,44),c=='e'?i+=i&1,j+=!(j&1):(i+=!(i&1),j+=j&1),o+=(j-i)/2:o+=j-i:0,++o;cout<<o;}

अधूरा :

void f()
{
  char c;
  int o=0,i,j;
  while(cin>>c)
    c=='p'||c==80?cin.ignore(9,58):cin.unget(),
    cin>>i>>c&&c==45?
      cin>>j>>c&&(c=='e'||c=='o')?
        cin.ignore(9,44),
        c=='e'?
          i+=i&1,j+=!(j&1)
        :(i+=!(i&1),j+=j&1),
        o+=(j-i)/2
      :o+=j-i
    :0,
    ++o;
  cout<<o;
}

मैंने यह नहीं कहा कि यह पठनीय होगा, अब मैंने किया? :) टर्नरी ऑपरेटर नरक हैं। मैंने इसकी पूरी कोशिश की (जैसे) इसे प्रारूपित किया, हालांकि, मुझे आशा है कि यह कम से कम थोड़ा मदद करता है।

उपयोग :

#include <iostream>
using namespace std;

void f(){char c;int o=0,i,j;while(cin>>c)c=='p'||c==80?cin.ignore(9,58):cin.unget(),cin>>i>>c&&c==45?cin>>j>>c&&(c=='e'||c=='o')?cin.ignore(9,44),c=='e'?i+=i&1,j+=!(j&1):(i+=!(i&1),j+=j&1),o+=(j-i)/2:o+=j-i:0,++o;cout<<o;}

int main()
{
  f();
}
— अलेक्जेंडर रेवो
स्रोत
— सीलिंगकैट
0

अजगर 2 - 163 बाइट्स:

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

इनपुट उद्धरणों के अंदर दिया जाना चाहिए 

import re
print len(eval(re.sub('([^,]+:|) *(\d+) *-? *(\d*)(?=.(.)).*?,',r'[x for x in range(\2,\3+1 if \3.0 else \2+1)if x%2!="oe".find("\4")]+',input()+',[]')))

स्पष्टीकरण:

सामान्य दृष्टिकोण मौजूदा इनपुट को वैध अजगर में बदलना है, फिर इसका मूल्यांकन करें। प्रत्येक अल्पविराम से अलग किया गया मान एक सरणी में बदल जाता है, जो तब सभी को एक साथ जोड़ दिया जाता है और लंबाई अंतिम परिणाम देती है।

उदाहरण के लिए, इनपुट के साथ 12-15 odd,19 , मूल्यांकन से पहले रेगेक्स प्रतिस्थापन का उत्पादन होगा:

[x for x in range(12,15+1 if 15.0 else 12+1)if x%2!="oe".find("o")]
+[x for x in range(19,+1 if .0 else 19+1)if x%2!="oe".find("[")]
+[]

इसे और तोड़ने के लिए:

  • 15+1 if 15.0 else 12+1 यह बिट सुनिश्चित करेगा कि श्रेणी का दूसरा तर्क () सही है यदि कोई सीमा दी गई है या एकल मान दिया गया है (यदि \ 3 खाली है, तो \ 3.0 गलत का मूल्यांकन करेगा) के आधार पर सही है।

  • if x%2!="oe".find("o") मूल्य के आधार पर रेंज में अंतिम अंक से दो अक्षर दूर पाए गए ((?=.(.)) रेगेक्स में - दो पात्रों को बिना उपभोग किए देखें), तीन संभावित परिणाम हैं:

    • x%2!="oe".find("o") का मूल्यांकन करता है x % 2 != 0(केवल विषम मिलान) का
    • x%2!="oe".find("e") का मूल्यांकन करता है x % 2 != 1(केवल मिलान भी) के
    • x%2!="oe".find("[") का मूल्यांकन करता है x % 2 != -1 (यह चरित्र कई चीजें हो सकती हैं क्योंकि यह अंतिम अंक से सिर्फ दो वर्ण दूर है, लेकिन केवल ओ या ई होगा यदि विषम / यहां तक ​​कि इरादा है)
  • अंत में प्रतीत होता है यादृच्छिक + [] यह सुनिश्चित करने के लिए है कि अल्पविराम से अलग की गई सूची में अंतिम टोकन में अंतिम अंक से दो दूर एक चरित्र है, लेकिन हमें अंतिम '+' का उपयोग करने के लिए कुछ को अंत तक जोड़ने की अनुमति देता है। जो अन्यथा पीछे चल रहा होता।
— Jarmex
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.