Al leer mi historia y tomar apuntes, no puedo evitar cansarme de escribir todas estas fechas largas: ¡1784 son seis elevadores de lápiz completos! jǝǝz!

Como puede ver, yo ––me gusta la mayoría de los pósters de desafío en este sitio– soy flojo cuando se trata de escribir cosas. Por lo tanto, le pido que me ayude a acortar algunas fechas. Por supuesto, su solución debe ser lo más breve posible ya que mi mano ya está cansada de escribir escribiendo los casos de prueba.

¿Cómo acorto una cita?

Bien gracioso deberías preguntar. Es bastante simple:

1. Tome dos enteros como entrada en el orden que desee ( (smallest, biggest)o (biggest, smallest)).
2. Tome el mayor de los dos números y tome solo la parte que no esté en el número más pequeño.
   Por ejemplo, dado 2010, 2017, acortar 2017a -7porque 201_está en ambos en los mismos lugares de dígitos.
3. Imprima o devuelva el número más pequeño, seguido de un guión y luego el número más corto acortado.

Por ejemplo:

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‚'-ý

Pruébalo en línea!

Utiliza el algoritmo de Jonathan Allan.

Jalea ,  17  16 bytes

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

Un programa completo que toma una lista de años from, toe imprime el resultado.

Pruébalo en línea! o ver el conjunto de pruebas .

¿Cómo?

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

Prueba:

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←⍕⍵}

Pruébalo en línea!

¿Cómo?

⍺,'-' - el primer año + , -

    =x←⍕⍵ - compara el segundo año formateado

    ((-⍴x)↑⍕⍺) - al primer año acolchado con espacios desde la izquierda

    ⌈\~ - niega el resultado y marca todos los 1 después del primero

x/⍨ - tomar el segundo año en todas las posiciones marcadas

Retina , 34 bytes

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

Pruébalo en línea! El enlace incluye casos de prueba. El grupo de equilibrio y el límite de la palabra aseguran que ambos números tengan la misma longitud antes de que coincida el prefijo. Si no, entonces el límite de la palabra coincide al comienzo del segundo año, por lo que todo lo que sucede es que la coma cambia a un guión.

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

Pruébalo en línea!

Siento que tiene que haber una mejor manera de hacerlo, ya que parece realmente detallado. Abuso extremo de la `` evaluación de variables para que esto funcione, ya que no podemos tomar cadenas como entrada.

Python 2, 127 bytes

Todavía soy nuevo en esto, así que no sé si está bien colocar otra respuesta en el mismo idioma. Como todavía no puedo comentar sobre las publicaciones de otras personas, me arriesgo aquí.

• ¿Está permitido cambiar la entrada de Integer a String? Porque eso me ahorraría alrededor de 10 bytes.
• La respuesta de Arnlod Parmers tiene un error en 1989, 1991. (durante el tiempo que publico esto). ¡Gracias por el `` truco de evaluación aunque (me ahorró 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

Pruébalo en línea!

Lo que hago es comparar cada dígito de ambas veces y si el más grande varía, imprimo el número más pequeño más el resto del más grande.

Si alguien pudiera ayudarme a jugar golf en la tercera línea, ahorraría más de 30 bytes. Solo lo implementé para manejar el caso de 600,6000 donde los dígitos son iguales pero no de la misma longitud.

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)

Pruébalo en línea!

smallest biggest entrada (enteros).

if length x<length y then ysignifica que si xtiene menos dígitos que yentonces la parte común es nula. De lo contrario, almacenamos los dígitos del yprimer 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):]

Pruébalo en línea!

Lisp común, 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))))))

Pruébalo en línea!

Más pequeño, más grande.

Sin golf:

(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 gracias 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 pruebas:

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