En lisant mon histoire et en prenant des notes, je ne peux m'empêcher de me lasser d'écrire toutes ces longues dates –– 1784, c'est six levées de crayon entières! jǝǝz!

Comme vous pouvez le voir, je –– comme la plupart des affiches de défi sur ce site –– je suis paresseux quand il s'agit d'écrire des choses. Je vous demande donc de bien vouloir m'aider à raccourcir certaines dates. Bien sûr, votre solution doit être aussi courte que possible car ma main est déjà fatiguée d' écrire en tapant les cas de test.

Comment raccourcir une date?

Eh bien, vous devriez demander. C'est assez simple:

1. Prenez deux entiers en entrée dans l'ordre que vous souhaitez ( (smallest, biggest)ou (biggest, smallest)).
2. Prenez le plus grand des deux nombres et ne prenez que la partie qui n'est pas dans le plus petit nombre.
   Par exemple, étant donné 2010, 2017, raccourcissez 2017à -7car se 201_trouve dans les deux aux mêmes emplacements numériques.
3. Imprimez ou renvoyez le plus petit nombre, suivi d'un tiret, puis du plus grand nombre raccourci.

Par exemple:

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 octets

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

Essayez-le en ligne!

Utilise l'algorithme de Jonathan Allan.

Gelée ,  17  16 octets

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

Un programme complet prenant une liste d'années from, toet imprimant le résultat.

Essayez-le en ligne! ou consultez la suite de tests .

Comment?

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 caractères

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

Tester:

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 octets

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

Essayez-le en ligne!

Comment?

⍺,'-' - la première année + , -

    =x←⍕⍵ - comparer la deuxième année formatée

    ((-⍴x)↑⍕⍺) - à la première année rembourré avec des espaces de gauche

    ⌈\~ - annuler le résultat et marquer tous les 1 après le premier

x/⍨ - prendre la deuxième année en toute position marquée

Rétine , 34 octets

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

Essayez-le en ligne! Le lien inclut des cas de test. Le groupe d'équilibrage et la limite de mot garantissent que les deux nombres sont de la même longueur avant que le préfixe ne soit mis en correspondance. Sinon, le mot limite correspond au début de la deuxième année, donc tout ce qui se passe est que la virgule se transforme en tiret.

Python 2 , 102 octets

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

Essayez-le en ligne!

J'ai l'impression qu'il doit y avoir une meilleure façon de le faire car cela semble vraiment verbeux. Abus extrême de `` l'évaluation des variables pour que cela fonctionne car nous ne pouvons pas prendre les chaînes en entrée.

Python 2, 127 octets

Je suis encore nouveau à ce sujet, donc je ne sais pas si c'est correct de placer une autre réponse dans la même langue. Comme je ne peux pas encore commenter les messages d'autres personnes, je tente ma chance ici.

• Est-il autorisé de changer l'entrée d'Integer en String? Parce que cela me ferait économiser environ 10 octets.
• La réponse d'Arnlod Parmers a une erreur sur 1989, 1991. (pendant le temps que je poste ceci). Merci tho pour le `` truc d'évaluation tho (ça m'a fait gagner un octet)!

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

Essayez-le en ligne!

Ce que je fais, c'est que je compare chaque chiffre des deux fois et si le plus grand varie, j'imprime le plus petit nombre plus le reste du plus grand.

Si quelqu'un pouvait m'aider à jouer sur la troisième ligne, j'économiserais plus de 30 octets. Je ne l'ai implémenté que pour gérer le cas de 600,6000 où les chiffres sont égaux mais pas de même longueur.

Haskell , 143 octets

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)

Essayez-le en ligne!

smallest biggest entrée (entiers).

if length x<length y then ysignifie que si xa moins de chiffres que yla partie commune est vide. Sinon, nous stockons les chiffres du ypremier chiffre différent.

Python 2 , 89 88 octets

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

Essayez-le en ligne!

Lisp commun, 120 octets

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

Essayez-le en ligne!

Le plus petit, le plus grand.

Non 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 octets

-14 octets grâce à 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);}

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