Facendo la lettura della mia storia e prendendo appunti, non posso fare a meno di stancarmi di scrivere tutte queste lunghe date - 1784 sono sei interi sollevamenti di matite! jǝǝz!

Come puoi vedere, mi piace la maggior parte dei poster di sfida su questo sito, sono pigro quando si tratta di scrivere cose. Pertanto, ti chiedo per favore di aiutarmi ad abbreviare alcune date. Certo, la tua soluzione deve essere il più corta possibile poiché la mia mano è già stanca di scrivere a mano i casi di test.

Come accorciare un appuntamento?

Bene divertente, dovresti chiedere. È abbastanza semplice:

1. Prendi due numeri interi come input nell'ordine che desideri ( (smallest, biggest)o (biggest, smallest)).
2. Prendi il più grande dei due numeri e prendi solo la parte non nel numero più piccolo.
   Ad esempio, dato 2010, 2017, abbreviato 2017in -7perché si 201_trova in entrambi gli stessi posti delle cifre.
3. Stampa o restituisci il numero più piccolo, seguito da un trattino e quindi dal numero più grande abbreviato.

Per esempio:

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 byte

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

Provalo online!

Utilizza l'algoritmo di Jonathan Allan.

Gelatina ,  17  16 byte

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

Un programma completo che prende un elenco di anni from, toe stampa il risultato.

Provalo online! o vedi la suite di test .

Come?

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 caratteri

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

Test:

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 byte

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

Provalo online!

Come?

⍺,'-' - il primo anno + , -

    =x←⍕⍵ - confronta il secondo anno formattato

    ((-⍴x)↑⍕⍺) - al primo anno imbottito con spazi da sinistra

    ⌈\~ - annulla il risultato e segna tutti gli 1 dopo il primo

x/⍨ - prendere il secondo anno in tutte le posizioni contrassegnate

Retina , 34 byte

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

Provalo online! Il link include casi di test. Il gruppo di bilanciamento e il confine della parola assicurano che entrambi i numeri abbiano la stessa lunghezza prima che il prefisso sia associato. In caso contrario, il limite di parole corrisponde all'inizio del secondo anno, quindi tutto ciò che accade è che la virgola si trasforma in un trattino.

Python 2 , 102 byte

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

Provalo online!

Sento che ci deve essere un modo migliore per farlo poiché sembra davvero prolisso. Abuso estremo della `` valutazione delle variabili affinché questo funzioni, poiché non possiamo prendere le stringhe come input.

Python 2, 127 byte

Sono ancora nuovo a questo, quindi non so se sia giusto inserire un'altra risposta nella stessa lingua. Dal momento che non posso ancora commentare i post di altre persone, colgo le mie possibilità qui.

• È consentito modificare l'input da Integer a String? Perché questo mi farebbe risparmiare circa 10 byte.
• La risposta di Arnlod Parmers ha un errore nel 1989, 1991. (durante il periodo in cui sto postando questo). Grazie per il `` trucco di valutazione tho (mi ha salvato un byte)!

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

Provalo online!

Quello che faccio è confrontare ogni singola cifra da entrambe le volte e se la più grande varia, stampa il numero più piccolo più il resto di quello più grande.

Se qualcuno potesse aiutarmi a giocare a golf sulla terza riga, risparmierei più di 30 byte. L'ho implementato solo per gestire il caso di 600.6000 in cui le cifre sono uguali ma non della stessa lunghezza.

Haskell , 143 byte

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)

Provalo online!

smallest biggest input (numeri interi).

if length x<length y then ysignifica che se xha meno cifre di yallora la parte comune è nulla. Altrimenti, memorizziamo le cifre della yprima cifra diversa.

Python 2 , 89 88 byte

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

Provalo online!

Lisp comune, 120 byte

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

Provalo online!

Più piccolo, più grande.

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 byte

-14 byte grazie a 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);}

Codice per il test:

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