Tarihimi okurken ve not alırken, yardım edemem ama tüm bu uzun tarihleri ​​yazmaktan bıktım - 1784 altı kalemliktir! jǝǝz!

Gördüğünüz gibi, –– bu sitedeki posterlerin çoğunu seviyorum - yazı yazmak söz konusu olduğunda tembelim. Bu yüzden sizden bazı tarihleri ​​kısaltmama yardım etmenizi rica ediyorum. Elbette, elim test senaryolarını yazmaktan zaten yorulduğundan, çözümünüz mümkün olduğunca kısa olmalıdır .

Bir tarihi nasıl kısaltabilirim?

Çok komik sormalısın. Oldukça basit:

1. İstediğiniz sırayla ( (smallest, biggest)veya (biggest, smallest)) girdi olarak iki tamsayı alın .
2. İki sayıdan daha büyük olanı alın ve yalnızca küçük sayıdan olmayan kısmı alın.
   Örneğin, belirli bir 2010, 2017kısaltmak 2017için -7, çünkü 201_aynı rakam-yerlerde her iki bulunmaktadır.
3. Küçük sayıyı, ardından bir tire ve ardından kısaltılmış daha büyük sayıyı yazdırın veya döndürün.

Örneğin:

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

05AB1E , 16 bayt

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

Çevrimiçi deneyin!

Jonathan Allan'ın algoritmasını kullanır.

Jöle ,  17  16 bayt

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

Yılların listesini alan from, tove sonucu basan tam bir program .

Çevrimiçi deneyin! veya test takımına bakın .

Nasıl?

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

Javascript ES6, 59 57 karakter

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

Ölçek:

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))

Dyalog APL, 29 bayt

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

Çevrimiçi deneyin!

Nasıl?

⍺,'-' - ilk yıl + , -

    =x←⍕⍵ - biçimlendirilen ikinci yılı karşılaştırın

    ((-⍴x)↑⍕⍺) - soldan boşluklarla dolu ilk yıla kadar

    ⌈\~ - sonucu ortadan kaldırın ve ilk 1'den sonra tüm 1'leri işaretleyin

x/⍨ - ikinci yılı tüm işaretli pozisyonlarda al

Retina , 34 bayt

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

Çevrimiçi deneyin! Bağlantı, test senaryolarını içerir. Dengeleme grubu ve sözcük sınırı, önek eşleştirilmeden önce her iki sayının da aynı uzunlukta olmasını sağlar. Değilse, sınır kelimesi ikinci yılın başlangıcında eşleşir, bu yüzden tüm bunlar virgülün kısa çizgiye dönüşmesidir.

Python 2 , 102 bayt

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

Çevrimiçi deneyin!

Gerçekten daha ayrıntılı göründüğü için bunu yapmanın daha iyi bir yolu olması gerektiğini hissediyorum. `` Dizeleri girdi olarak alamadığımız için bunun çalışması için değişkenlerin değerlendirilmesi aşırı istismar.

Python 2, 127 bayt

Bu konuda hala yeniyim, bu yüzden aynı dilde başka bir cevap vermenin uygun olup olmadığını bilmiyorum. Diğer insanların gönderileri hakkında yorum yapamadığım için burada şansımı değerlendiriyorum.

• Girişin Tamsayıdan Dize'ye değiştirilmesine izin veriliyor mu? Çünkü bu beni 10 byte civarında kurtaracaktı.
• Arnlod Parmers cevabının 1989, 1991'de bir hatası var. (Bunu gönderirken). Tho için teşekkür ederim tho `` değerlendirme hilesi tho (bana bir bayt kurtardı)!

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

Çevrimiçi deneyin!

Yaptığım şey, her bir basamağı iki kez karşılaştırıyorum ve daha büyük olanı değişirse, daha küçük sayıyı artı daha büyük olanı yazdırırım.

Birisi bana üçüncü satır golf yardımcı olabilir, ben 30 + bayt gibi tasarruf. Bunu yalnızca basamakların eşit olduğu ancak aynı uzunlukta olmadığı 600.6000 kasasını işlemek için uyguladım.

Haskell , 143 bayt

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)

Çevrimiçi deneyin!

smallest biggest girdi (tamsayılar).

if length x<length y then yanlamına gelir, o xzamandan daha az basamak varsa , yortak kısım geçersizdir. Aksi takdirde y, ilk farklı basamaktaki rakamları saklarız .

Python 2 , 89 88 bayt

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

Çevrimiçi deneyin!

Ortak Lisp, 120 bayt

(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))))))

Çevrimiçi deneyin!

En küçük, en büyük.

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

C ++, 285 271 bayt

Zacharý sayesinde -14 bayt

#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);}

Test kodu:

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';
}