Wenn ich meine Geschichte lese und Notizen mache, kann ich es nicht lassen, all diese langen Datteln aufzuschreiben - 1784 sind sechs komplette Bleistiftlifte! jǝǝz!

Wie Sie sehen, bin ich - wie die meisten Herausforderungsposter auf dieser Website - faul, wenn es darum geht, Dinge zu schreiben. Deshalb bitte ich Sie, mir bei der Verkürzung einiger Daten zu helfen. Natürlich muss Ihre Lösung so kurz wie möglich sein, da meine Hand bereits müde vom Schreiben der Testfälle ist.

Wie verkürze ich ein Date?

Na witzig solltest du fragen. Es ist ziemlich einfach:

1. Nehmen Sie zwei Ganzzahlen als Eingabe in beliebiger Reihenfolge ( (smallest, biggest)oder (biggest, smallest)).
2. Nehmen Sie die größere der beiden Zahlen und nehmen Sie nur den Teil, nicht die kleinere Zahl.
   Beispiel: 2010, 2017Verkürzen 2017auf, -7weil 201_sich beide Zeichen an denselben Stellen befinden.
3. Drucken Sie die kleinere Zahl aus oder geben Sie sie zurück, gefolgt von einem Bindestrich und der verkürzten größeren Zahl.

Beispielsweise:

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

Probieren Sie es online!

Verwendet Jonathan Allans Algorithmus.

Jelly ,  17  16 Bytes

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

Ein vollständiges Programm, das eine Liste von Jahren erstellt from, tound das Ergebnis druckt.

Probieren Sie es online! oder sehen Sie sich die Testsuite an .

Wie?

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 Zeichen

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

Prüfung:

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

Probieren Sie es online!

Wie?

⍺,'-' - das erste Jahr + , -

    =x←⍕⍵ - Vergleiche das zweite formatierte Jahr

    ((-⍴x)↑⍕⍺) - bis zum ersten Jahr mit Leerzeichen von links aufgefüllt

    ⌈\~ - negiere das Ergebnis und markiere alle Einsen nach dem ersten

x/⍨ - Nehmen Sie das zweite Jahr in allen markierten Position

Retina , 34 Bytes

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

Probieren Sie es online! Link enthält Testfälle. Die Bilanzgruppe und die Wortgrenze stellen sicher, dass beide Zahlen dieselbe Länge haben, bevor das Präfix abgeglichen wird. Wenn nicht, stimmt die Wortgrenze zu Beginn des zweiten Jahres überein, sodass sich das Komma lediglich in einen Bindestrich ändert.

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

Probieren Sie es online!

Ich denke, es muss einen besseren Weg geben, um dies zu tun, da es sehr ausführlich zu sein scheint. Extremer Missbrauch der `` Auswertung von Variablen, damit dies funktioniert, da wir keine Zeichenfolgen als Eingabe verwenden können.

Python 2, 127 Bytes

Ich bin noch neu in diesem Bereich, daher weiß ich nicht, ob es in Ordnung ist, eine andere Antwort in derselben Sprache zu verfassen. Da ich die Beiträge anderer Leute noch nicht kommentieren kann, gehe ich hier mein Risiko ein.

• Darf die Eingabe von Integer in String geändert werden? Das würde mir ungefähr 10 Bytes sparen.
• Arnlod Parmers Antwort hat einen Fehler am 1989, 1991. (während der Zeit, in der ich dies poste). Vielen Dank für den `` Bewertungstrick (es hat mir ein Byte erspart)!

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

Probieren Sie es online!

Was ich tue, ist, ich vergleiche jede einzelne Ziffer von beiden Malen und wenn die größere variiert, drucke ich die kleinere Zahl plus den Rest der größeren.

Wenn mir jemand beim Golfspielen in der dritten Reihe helfen könnte, würde ich mehr als 30 Bytes sparen. Ich habe es nur implementiert, um den Fall von 600.6000 zu behandeln, bei dem die Ziffern gleich, aber nicht gleich lang sind.

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)

Probieren Sie es online!

smallest biggest Eingabe (ganze Zahlen).

if length x<length y then ybedeutet, dass der gemeinsame Teil ungültig ist , wenn er xweniger Ziffern hat als y. Ansonsten speichern wir die Ziffern yder ersten unterschiedlichen Ziffer.

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

Probieren Sie es online!

Common Lisp, 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))))))

Probieren Sie es online!

Kleinste, größte.

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 dank 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 zum Testen:

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