इतिहास होमवर्क हेल्पर

Question

मेरे इतिहास को पढ़ने और नोट करने में, मैं मदद नहीं कर सकता, लेकिन इन सभी लंबी तारीखों को लिखने से थक जाता हूं- 1784 में छह संपूर्ण पेंसिल लिफ्ट हैं! jǝǝz!

जैसा कि आप देख सकते हैं, मैं इस साइट पर सबसे ज्यादा चुनौती देने वाले पोस्टर पसंद करता हूं — जब सामान लिखने की बात होती है तो मैं आलसी हो जाता हूं। इस प्रकार, मैं आपसे कुछ तिथियों को छोटा करने में मदद करने के लिए कहता हूं। बेशक, आपका समाधान यथासंभव कम होना चाहिए क्योंकि मेरे हाथ पहले से ही परीक्षण के मामलों को लिखने से थक गए हैं।

मैं एक तारीख को कैसे छोटा करूं?

खैर मज़ाक आपको पूछना चाहिए। यह काफी सरल है:

1. जो भी आप चाहते हैं ( (smallest, biggest)या (biggest, smallest)) में दो पूर्णांकों को इनपुट के रूप में लें ।
2. दो संख्याओं में से बड़ा लें, और केवल उस भाग को लें जो छोटी संख्या में न हो।
   उदाहरण के लिए, यह देखते हुए 2010, 2017, छोटा 2017करने के लिए -7क्योंकि 201_एक ही अंकों-स्थानों पर दोनों में है।
3. छोटी संख्या को प्रिंट करें या वापस करें, इसके बाद डैश और उसके बाद छोटा नंबर।

उदाहरण के लिए:

Bonus brownies for you if you figure out these dates' significance :)
1505, 1516 -> 1505-16
1989, 1991 -> 1989-91
1914, 1918 -> 1914-8
1833, 1871 -> 1833-71
1000, 2000 -> 1000-2000
1776, 2017 -> 1776-2017
2016, 2016 -> 2016-

These dates lack significance :(
1234567890, 1234567891 -> 1234567890-1
600, 1600 -> 600-1600
1235, 1424 -> 1235-424
600, 6000 -> 600-6000

Comments

1914-18या 1914-8?

— एंडर्स कासोर्ग

600, 6000 -> 600-6000?

— क्वाटर्ली

@JonathanAllan, हाँ यह सही है। इनपुट केवल nonnegative पूर्णांक है

— डैनियल

@ क्वर्टी, वास्तव में।

— डैनियल

1914-8WWI है। अब मेरे गोरों को शर्म करो!

— आउटगोल्फ जूल

Answer 1

05AB1E , 16 बाइट्स

`R¹íζ€Ë1Üg£R‚'-ý

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

जोनाथन एलन के एल्गोरिथ्म का उपयोग करता है।

Answer 2

जेली ,  17  16 बाइट्स

DUµn/TṪṁ@Ṫ,j”-FṚ

एक पूर्ण कार्यक्रम वर्षों की सूची ले रहा है from, toऔर परिणाम प्रिंट कर रहा है।

इसे ऑनलाइन आज़माएं! या परीक्षण सूट देखें।

कैसे?

DUµn/TṪṁ@Ṫ,j”-FṚ - Main link: list of years [from, to]    e.g [1833,1871]
D                - convert to decimals                        [[1,8,3,3],[1,8,7,1]]
 U               - upend (to cater for differing lengths)     [[3,3,8,1],[1,7,8,1]]
  µ              - monadic chain separation, call that V
    /            - reduce V with:
   n             -   not equal?                               [1,1,0,0]
     T           - truthy indices                             [1, 2]
      Ṫ          - tail                                       2
         Ṫ       - tail V (pop from & modify V)               [1,7,8,1]
       ṁ@        - mould (swap @rguments) V like that length  [1,7]
          ,      - pair that with (the modified) V            [[1,7],[[3,3,8,1]]
            ”-   - literal '-' character
           j     - join                                       [1,7,'-',[3,3,8,1]]
              F  - flatten                                    [1,7,'-',3,3,8,1]
               Ṛ - reverse                                    [1,8,3,3,'-',7,1]
                 - implicit print                             1833-71

Comments

पहले तो मुझे लगा कि मैंने इस बात को गलत बताया है ... फिर लानत [600, 6000]दिखाई दी। और ऐसा लगता है कि यह पूर्ववत् किया गया है।

— आउटगोल्फ जूल

Answer 3

जावास्क्रिप्ट ईएस 6, 59 57 वर्ण

(x,y)=>(x+'-'+y).replace(x*10>y?/^((.*).*-)\2/:/()/,"$1")

परीक्षा:

f=(x,y)=>(x+'-'+y).replace(x*10>y?/^((.*).*-)\2/:/()/,"$1")

console.log(`1505, 1516 -> 1505-16
1989, 1991 -> 1989-91
1914, 1918 -> 1914-8
1833, 1871 -> 1833-71
1000, 2000 -> 1000-2000
1776, 2017 -> 1776-2017
2016, 2016 -> 2016-
1234567890, 1234567891 -> 1234567890-1
600, 1600 -> 600-1600
1235, 1424 -> 1235-424`.split`
`.map(t => t.match(/(\d+), (\d+) -> (.*)/)).every(([m,x,y,key]) => f(x,y)===key || console.log(x,y,key,f(x,y))))
console.log(f(600,6000))

Comments

बस कोशिश करो (x+'-'+y)?

— tsh

f (180, 1600) ->?

— tsh

x=>y=>एक बाइट को बचाने के लिए करी ( ) का उपयोग करें ।

— द लीथेलकोडर

Answer 4

दिल्लोग एपीएल, 29 बाइट्स

{⍺,'-',x/⍨⌈\~((-⍴x)↑⍕⍺)=x←⍕⍵}

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

कैसे?

⍺,'-' - पहला साल + , -

    =x←⍕⍵ - दूसरे वर्ष की तुलना स्वरूपित करें

    ((-⍴x)↑⍕⍺) - पहले साल के लिए बाईं ओर से रिक्त स्थान के साथ गद्देदार

    ⌈\~ - परिणाम को नकारात्मक करें और पहले के बाद सभी 1s को चिह्नित करें

x/⍨ - दूसरे वर्ष को सभी चिन्हित स्थिति में ले जाएं

Answer 5

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

(.*)((.)*),\1((?<-3>.)*)\b
$1$2-$4

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं। संतुलन समूह और शब्द सीमा सुनिश्चित करते हैं कि उपसर्ग के मिलान से पहले दोनों संख्याएं समान लंबाई हैं। यदि नहीं, तो शब्द सीमा दूसरे वर्ष की शुरुआत में मेल खाती है, इसलिए यह सब होता है कि अल्पविराम एक डैश में बदल जाता है।

Answer 6

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

lambda s,n:`s`+'-'+[[`n`[i:]for i in range(len(`s`)+1)if `n`[:i]==`s`[:i]][-1],`n`][len(`n`)>len(`s`)]

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

मुझे लगता है कि ऐसा करने का एक बेहतर तरीका होना चाहिए क्योंकि यह वास्तव में क्रिया है। जब हम इनपुट के रूप में तार नहीं ले सकते हैं, तो काम करने के लिए चर के `` मूल्यांकन का चरम दुरुपयोग।

Comments

"100-99" के बजाय a = 100, b = 199 रिटर्न "100-199"।

— चास ब्राउन

@ChasBrown डांग, आप सही कह रहे हैं। मैंने अपने कोड को पिछले पुनरावृत्ति में वापस ले लिया, जो इस मामले का ध्यान रखता है।

— अर्नोल्ड पामर

Answer 7

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

मैं अभी भी इसके लिए नया हूं, इसलिए मुझे नहीं पता कि क्या उसी भाषा में एक और उत्तर देना ठीक है। चूँकि मैं अन्य लोगों के पदों पर टिप्पणी नहीं कर सकता, फिर भी मैं अपने मौके यहाँ ले जा रहा हूँ।

• क्या इंटेगर से स्ट्रिंग में इनपुट को बदलने की अनुमति है? कारण है कि मुझे 10 बाइट के आसपास बचा लेगा।
• अर्नलॉड परमर्स उत्तर में 1989, 1991 की गलती है। (जिस समय मैं यह पोस्ट कर रहा हूं)। धन्यवाद `` मूल्यांकन चाल के लिए यद्यपि (यह मुझे एक बाइट बचा)!

def f(s,b):
 s=`s`+'-'
 if len(`b`)>=len(s):return s+`b`
 for i in range(len(`b`)):
    if s[i]!=`b`[i]:return s+`b`[i:]
 return s

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

मैं क्या कर रहा हूं, मैं दोनों समय से प्रत्येक एकल अंक की तुलना करता हूं और यदि बड़ा भिन्न होता है तो मैं छोटी संख्या और बाकी बड़ी संख्या को प्रिंट करता हूं।

अगर कोई मुझे तीसरी पंक्ति में गोल्फ में मदद कर सकता है तो मैं 30+ बाइट्स की तरह बचाऊंगा। मैंने इसे केवल ६००,६००० के मामले को संभालने के लिए लागू किया है जहाँ अंक समान हैं, लेकिन समान लंबाई नहीं है।

Comments

हाँ, कई भाषाओं में एक ही प्रश्न का उत्तर देना ठीक है, और आपको स्ट्रिंग के रूप में इनपुट लेने की अनुमति है।

— जियोकॉवेल

Answer 8

हास्केल , 143 बाइट्स

g x y=h(show x)(show y)
h x y=x++"-"++if length x<length y then y else foldl(\a(c,d)->if a==[]then if c==d then[]else[d]else a++[d])[](zip x y)

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

smallest biggest इनपुट (पूर्णांक)।

if length x<length y then yइसका मतलब है कि अगर xकम अंक हैं yतो आम हिस्सा शून्य है। और, हम yपहले अलग-अलग अंकों के अंकों को संग्रहीत करते हैं ।

Answer 9

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

lambda a,b:`a`+'-'+`b`[map(lambda c,d:(len(`a`)==len(`b`))*(c==d),`a`,`b*10`).index(0):]

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

Answer 10

आम लिस्प, 120 बाइट्स

(lambda(s b &aux(d(#1=format()"~a"b)))(#1#()"~a-~a"s(if(<=(* s 10)b)b(subseq d(or(mismatch d(#1#()"~a"s))(length d))))))

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

सबसे छोटा, सबसे बड़ा।

Ungolfed:

(defun f(s b &aux (d (format () "~a" b)))   ; s and b parameters, d string from s
  (format () "~a-~a" s                     ; print first number, then -, then abbreviation
      (if (<= (* s 10) b)                  ; if b is too large do not abbreviate
          b
          (subseq d (or (mismatch d (format () "~a" s)) ; else find first mismatch
                        (length d))))))    ; then extract the last part from mismatch
                                           ; or nothing if they are equal

Answer 11

सी ++, 285 271 बाइट्स

-14 बाइट्स Zacharý को धन्यवाद

#include<iostream>
#include<string>
#define S s.size()
#define R r.size()
using namespace std;void h(int a,int b){auto r=to_string(a),s=to_string(b);if(R>S)s=string(R-S,' ')+s;if(S>R)r=string(S-R,' ')+r;int i=0;for(;i<R;++i)if(r[i]!=s[i])break;cout<<a<<'-'<<s.substr(i);}

परीक्षण के लिए कोड:

std::vector<std::pair<int, int>> test = {
    {1505,1516},
    {1989,1991}, //End of the cold war
    {1914,1918}, //First world war start and end
    {1833,1871},
    {1000,2000}, //2000 = Y2K bug, 1000 is... well... Y1K bug ? :)
    {1776,2017}, //US constitution signed the 4th july, French elections & year of the C++ 17 standard
    {2016,2016}, //US elections
    {1234567890,1234567891},
    {600,1600},
    {1235,1424},
    {600,6000}
};

for (auto&a : test) {
    h(a.first, a.second);
    std::cout << '\n';
}

Comments

आप मैक्रो using namespace std;को हटाकर कुछ बाइट्स बचा सकते हैं T।

— ज़ाचरी