Ao ler minha história e fazer anotações, não posso deixar de me cansar de escrever todas essas longas datas - 1784 são seis elevadores de lápis inteiros! jz!

Como você pode ver, eu - como a maioria dos pôsteres de desafio deste site - sou preguiçoso quando se trata de escrever coisas. Portanto, peço que me ajude a reduzir algumas datas. Obviamente, sua solução deve ser o mais curta possível, pois minha mão já está cansada de escrever digitando os casos de teste.

Como reduzo um encontro?

Bem engraçado, você deveria perguntar. É bem simples:

1. Tome dois números inteiros como entrada na ordem que desejar ( (smallest, biggest)ou (biggest, smallest)).
2. Pegue o maior dos dois números e pegue apenas a parte que não está no número menor.
   Por exemplo, dado 2010, 2017, reduza 2017para -7porque 201_está nos dois dígitos iguais.
3. Imprima ou retorne o número menor, seguido de um traço e, em seguida, o número maior reduzido.

Por exemplo:

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 bytes

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

Experimente online!

Usa o algoritmo de Jonathan Allan.

Geléia ,  17  16 bytes

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

Um programa completo com uma lista de anos from, toe a impressão do resultado.

Experimente online! ou veja a suíte de testes .

Quão?

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 caracteres

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

Teste:

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 bytes

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

Experimente online!

Quão?

⍺,'-' - o primeiro ano + , -

    =x←⍕⍵ - compare o segundo ano formatado

    ((-⍴x)↑⍕⍺) - para o primeiro ano preenchido com espaços da esquerda

    ⌈\~ - negar o resultado e marcar todos os 1s após o primeiro

x/⍨ - faça o segundo ano em todas as posições marcadas

Retina , 34 bytes

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

Experimente online! O link inclui casos de teste. O grupo de balanceamento e o limite da palavra garantem que ambos os números tenham o mesmo comprimento antes da correspondência do prefixo. Caso contrário, o limite da palavra corresponderá no início do segundo ano, então tudo o que acontece é que a vírgula muda para um hífen.

Python 2 , 102 bytes

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

Experimente online!

Sinto que deve haver uma maneira melhor de fazer isso, pois parece realmente detalhado. Abuso extremo da `` avaliação de variáveis ​​para que isso funcione, pois não podemos usar seqüências de caracteres como entrada.

Python 2, 127 bytes

Eu ainda sou novo nisso, então não sei se posso colocar outra resposta no mesmo idioma. Como ainda não posso comentar sobre as postagens de outras pessoas, tomo minhas chances aqui.

• É permitido alterar a entrada de Inteiro para String? Porque isso me salvaria em torno de 10 bytes.
• A resposta de Arnlod Parmers tem um erro em 1989, 1991. (durante o tempo em que estou postando isso). Obrigado tho pelo `` truque de avaliação tho (ele me salvou um 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

Experimente online!

O que faço é comparar cada dígito dos dois tempos e, se o maior variar, imprimo o número menor mais o resto do maior.

Se alguém pudesse me ajudar a jogar na terceira linha, eu economizaria mais de 30 bytes. Eu apenas o implementei para lidar com o caso de 600.6000, onde os dígitos são iguais, mas não do mesmo comprimento.

Haskell , 143 bytes

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)

Experimente online!

smallest biggest entrada (inteiros).

if length x<length y then ysignifica que se xtiver menos dígitos do que ya parte comum será nula. Senão, armazenamos os dígitos do yprimeiro dígito diferente.

Python 2 , 89 88 bytes

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

Experimente online!

Lisp comum, 120 bytes

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

Experimente online!

Menor, Maior.

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 bytes

-14 bytes graças 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);}

Código para teste:

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