कागज और लिफाफा आकार

17

कार्य

पत्र (ए, बी, सी), और एक संख्या (0-10) को देखते हुए, प्रारूप में मिलीमीटर में मिलान मानक पेपर आकार (श्रृंखला ए और बी) या मिलान मानक लिफाफा आकार (सी श्रृंखला) के आकार का उत्पादन करता है। aaaa x bbbbजहां aaaaऔर bbbbप्रति ISO216 (सीरीज ए एंड बी) के रूप में या मिलीमीटर में चौड़ाई और ऊंचाई माप हैं ISO296 (श्रृंखला सी)

चीजों को आसान बनाने के लिए मैं विकिपीडिया के पेपर आकार की तालिका से उद्धृत करूंगा

ISO paper sizes in portrait view
Format  A series    B series    C series
Size     mm × mm      mm × mm    mm × mm
0       841 × 1189  1000 × 1414 917 × 1297
1       594 × 841    707 × 1000 648 × 917
2       420 × 594    500 × 707  458 × 648
3       297 × 420    353 × 500  324 × 458
4       210 × 297    250 × 353  229 × 324
5       148 × 210    176 × 250  162 × 229
6       105 × 148    125 × 176  114 × 162
7        74 × 105     88 × 125   81 × 114
8        52 × 74      62 × 88    57 × 81
9        37 × 52      44 × 62    40 × 57
10       26 × 37      31 × 44    28 × 40

इनपुट और आउटपुट के उदाहरण:

**Test case 1**
Input: A4
Output: 210 x 297

**Test Case 2**
Input: B6
Output: 125 x 176

**Test Case 3**
Input: C2
Output: 458 x 648

ध्यान देने योग्य बातें:

  1. प्रारूप "210 x 297" या "1000 x 1414" आदि। जबकि यह बेहतर प्रारूप है, आप अपने आउटपुट से "x" को छोड़ना चुन सकते हैं, अर्थात एक सरणी या दो संख्याओं के रूप में या जो भी आपके फैंस को गुदगुदी करता है जब तक चौड़ाई माप ऊंचाई से पहले आउटपुट किया जाता है।
  2. ऊंचाई और चौड़ाई के बीच का अनुपात लगभग 2 के वर्गमूल के बराबर है, इसलिए ऊंचाइयों की गणना में, चौड़ाई को sqrt (2) से गुणा किया जाता है, और फिर निकटतम मिलीमीटर तक ऊपर या नीचे गोल किया जाता है, इस प्रकार परिणामस्वरूप ऊपर तालिका में माप। यह आपके कोड को नीचे लाने में मदद कर सकता है।
  3. एक श्रृंखला के लिए क्रमिक आकारों में जैसे ही आप टेबल के नीचे जाते हैं, एक आकार की चौड़ाई अगले के लिए ऊँचाई बन जाती है। इससे आपको अपने कोड को नीचे लाने में भी मदद मिल सकती है।

नियम:

  1. यह कोड-गोल्फ है। परिणामस्वरूप मानक नियम लागू होते हैं। स्कोर बाइट काउंट पर आधारित होगा। सबसे कम गिनती जीतेंगे।
  2. कोई मूर्खतापूर्ण खामियां , हम पहले भी रहे हैं ... हम फिर से इस माध्यम से नहीं जाएंगे।
  3. यदि आप इसे कोड कर सकते हैं, तो कृपया अपने कोड के कामकाजी उदाहरण के लिए एक लिंक संलग्न करने पर भी विचार करें ताकि अन्य प्रोग्रामर और गोल्फर सीख सकें कि आपका कोड कैसे काम करता है। यह अनिवार्य नहीं है, लेकिन मैं दूसरों को ऐसा करने के लिए प्रोत्साहित करना चाहूंगा ताकि हम सभी एक-दूसरे को सीख सकें। मैं निश्चित रूप से अन्य गोल्फर की भाषाओं के बारे में अधिक जानना चाहूंगा जहां संभव हो।

शुभकामनाएँ।

code-golf 
— WallyWest
स्रोत
Bn An और An + 1 का ज्यामितीय माध्य है, और Cn An और Bn का ज्यामितीय माध्य है।
— 10:15 बजे Adám
— सिंह

जवाबों:

9

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

@WallyWest को 1 बाइट धन्यवाद दिया गया

s=>n=>[n,n-1].map(x=>.707**x*{A:841,B:1e3,C:917}[s]+.2|0)
— ETHproductions
स्रोत
3
अच्छा काम ... आप इसे 57 के साथ बना सकते हैं s=>n=>[n,n-1].map(x=>.707**x*{A:841,B:1e3,C:917}[s]+.2|0)और यह अभी भी आपके आउटपुट में एक ही सटीक होगा।
— वैलेस्ट वेस्ट
@ टिप के लिए धन्यवाद। मैं के लिए विभिन्न प्रतिस्थापन के साथ चारों ओर खेला था .7071और .2थोड़ी देर के लिए और सिर्फ थोड़े छोड़ दिया जब मैं कुछ है कि काम मिल गया: पी
— ETHproductions
कोई चिंता नहीं, कोड गोल्फ के नाम पर सभी ...;) मुझे ऐसा नहीं लगा कि नक्शे ने किसी वस्तु के भीतर बिना किसी चाबी के संदर्भ के लिए अनुमति दी हो ...? मुझे कुछ समय पहले ही इसका इस्तेमाल करना होगा ...
— वैलीवेस्ट
1
@WallyWest जिसका कोई लेना-देना नहीं है .map, आप {key1:1,key2:2,key3:3}[myKey]कभी भी अपनी इच्छानुसार उपयोग कर सकते हैं । यदि आपको मान्य चर नाम नहीं हैं, तो आपको केवल कुंजियों को उद्धृत करना होगा।
— ETHproductions
शानदार, टिप के लिए धन्यवाद ...
— वैलीवेस्ट
6

C (gcc) , 113 111 90 78 70 बाइट्स

इसे -lmTIO पर चलाने की आवश्यकता है, लेकिन विकल्प के बिना मेरे कंप्यूटर पर अच्छी तरह से काम करता है।

सहेजे गए 20 बाइट्स pizzapants184 के लिए धन्यवाद ।

पॉइंटर द्वारा मान लौटाएं।

f(a,b,c,d)int*c,*d;{float x=1e3*pow(.707,b+a%3/4.)+.2;*c=x,*d=x/.707;}

स्पष्टीकरण:

f(a,b,c,d)int*c,*d;{          // calling by char, but receive as int
    float x = 1e3 * pow(.707, // float gives enough precision 
            a % 3 / 4.        // series: a%3/4.=.5,0,.25 when a=65,66,67
            + b) - .2;        // magic number to get correct roundings
    *c = x, *d = x / .707;
}
— कोलेरा सु
स्रोत
1
— -m
1
91 बाइट्स(a^66?a^67:0.5:0.25:0)abs(a-66)/(a-63.)
— -lm
3

बैच, 105 बाइट्स

@set/aA=1189,B=1414,C=1297,h=%1,w=h*29/41
@for /l %%i in (1,1,%2)do @set/at=w,w=h/2,h=t
@echo %w% x %h%

41/29 ≅ ≅2

— नील
स्रोत
क्या बैच, @ नील में दशमलव संभव नहीं हैं? मैंने सोचा h*.707होगा कि बेहतर होगा h*41/29? आप पर ध्यान दें, सन्निकटन का सरल उपयोग!
— वॉलीवेस्ट
@WallyWest नहीं, 32-बिट पूर्णांक पर हस्ताक्षर किए।
— नील
ओह मैं समझा! प्रति दिन कुछ नया सीखें!
— वॉलीवेस्ट
3

जावास्क्रिप्ट, 53 बाइट्स

L=>N=>[N+1,N].map(p=>1091/2**(p/2+~{B:2,C:1}[L]/8)|0)

कोड स्निपेट दिखाएं

नील के लिए धन्यवाद, वैकल्पिक आउटपुट प्रारूप का उपयोग करके कई बाइट्स सहेजें।

— TSH
स्रोत
1
६६ बाइट्स:L=>N=>(g=p=>1000.2/2**(N/2+p-{A:2,B:4,C:3}[L]/8)|0)(.5)+' x '+g(0)
— नील
1
या यदि आप वैकल्पिक आउटपुट प्रारूप का उपयोग करते हैं तो 58 बाइट्स:L=>N=>[N+1,N].map(p=>1000.2/2**(p/2-{A:2,B:4,C:3}[L]/8)|0)
— नील
@ नील का संपादन किया। और 56 बाइट्स तक कम हो गई
— tsh
3

जावा (ओपनजेडके 8) , 59 बाइट्स

f->s->new double[]{s=1e3*Math.pow(.707,s+f%3/4d)-.2,s/.707}

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

@ कोलेरा सु की सी प्रविष्टि से प्रेरित , फिर अपने आप में सुधार।

  • केविन क्रूज़सेन की बदौलत 14 बाइट बच गए
— ओलिवियर ग्रेजायर
स्रोत
1
1000हो सकता है 1e3।
— केविन क्रूजसेन
1
— केविन क्रूज़सेन
3

APL (Dyalog) , 31 28 बाइट्स

-2 ngn के लिए धन्यवाद।

पूरा कार्यक्रम निकाय मान लिया गया है ⎕IO( मैं ndex हे rigin) होने के लिए 0है, जो कई सिस्टम पर डिफ़ॉल्ट है। नंबर के लिए संकेत, फिर पत्र, दोनों STDIN से। प्रिंट करने के लिए प्रिंट।

⌊.2+1E3÷2*8÷⍨('BC'⍳⍞)+4×⎕-⍳2

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

थोड़ा संशोधित संस्करण हमें एक बार में सभी संभावनाओं का परीक्षण करने देता है: इसे ऑनलाइन आज़माएं!

⍳2 पहले दो ɩ ndices, यानी 0 और 1

⎕- संख्यात्मक इनपुट से घटाएँ

4× उसके साथ चार गुणा करें

(...)+  निम्नलिखित जोड़ें

 ⍞ चरित्र इनपुट…

 'BC'⍳ ... की ɩ इस स्ट्रिंग में ndex

8÷⍨ उसको 8 से भाग दें

2* उस की शक्ति के लिए 2 बढ़ाएँ

1E3÷ 1000 उस से विभाजित

.2+ उसमें that जोड़ें

⌊ मंजिल (नीचे दौर)

— एडम
स्रोत
@ H.PWiz हां। टाइपो। धन्यवाद।
— एडम
2

Befunge, 69 56 55 बाइट्स

"}"8*~3%:"L"*7vv\p00-1_$..@
")"*":":-*!!\+<>2/00g:^:&\/

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

व्याख्या

हमारे पास फ़्लिंग पॉइंट या बेफ़ुंज में पावर फ़ंक्शन की तरह कुछ भी नहीं है, इसलिए हम दिए गए प्रारूप चरित्र, एफ के लिए आधार आकार की गणना निम्नानुसार करते हैं:

fn = f % 3
width = 1000 - (n * 76 + 7) * !!n
height = width * 58 / 41

फिर हम बार-बार इन आयामों को घुमाते हैं और विभाजित करते हैं ताकि दिए गए आकार की संख्या के लिए उपयुक्त उपखंड प्राप्त किया जा सके।

"}"8*                         Push 1000 for later use in the width calculation.
     ~                        Read the format character from stdin.
      3%                      Convert into a number in the range 0 to 2.
        :"L"*7v               Calculate width = 1000 - (fn * 76 + 7) * !!fn
        -*!!\+<                  where fn is the format number derived above.
")"*":":                  /   Calculate height = width * 58 / 41.
                         \    Swap so the width is above the height on the stack.
                      v:&     Read the numeric size from stdin and duplicate for testing.
                      _       While not zero, go left.
                 p00-1        Decrement the size and move it from the stack into memory.
               v/             Swap the width and height.
               >2/            Divide the new width by 2.
                  00g:        Restore the size from memory and duplicate for testing.
                      _       While not zero, repeat this loop.
                       $      When zero, continue to the right and drop the size.
                        ..@   Output the width and height, then exit.
— जेम्स होल्डरनेस
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.