Eine Schanzennummer ist eine Zahl mit der gleichen Ziffer in der ersten und der letzten , aber das ist noch nicht alles. Bei einer Bergzahl steigen die ersten Ziffern stark an und die letzten Ziffern fallen stark ab. Die größte Ziffer kann wiederholt werden .

Hier ist ein Beispiel für eine Bergnummer:

12377731 | 1237...             | ...731
^ same ^ | strictly increasing | strictly decreasing 
---------+---------------------+---------------------
12377731
   ^^^ okay because largest digit can be repeated

Das ist nicht :

4588774 | ...8774
        |     ^^ not the largest digit
        |        so this has to be strictly decreasing
        |        but it's not, so not a hill number

Herausforderung

Schreiben Sie bei einer positiven Ganzzahl ein vollständiges Programm oder eine Funktion, die für Bergzahlen die Wahrheit zurückgibt, bei anderen Werten jedoch die Wahrheit.

Anmerkungen:

• Eingabe und Ausgabe können in jedem vernünftigen Format erfolgen .
• Dies ist Code-Golf, also gewinnt die kürzeste Antwort in jeder Sprache!

Testfälle

12321 -> Truthy
1233321 -> Truthy
99 -> Truthy
3 -> Truthy
234567992 -> Truthy
1232 -> Falsy
778896 -> Falsy
23232 -> Falsy
45566554 -> Falsy
5645 -> Falsy

Gelee , 8 Bytes

_ƝṠÞ+SƊƑ

Probieren Sie es online!

Wie es funktioniert

_ƝṠÞ+SƊƑ  Main link. Argument: n (integer)

_Ɲ        Take the differences of neighboring digits.
          This maps n = abcd to [a-b, b-c, c-d].
       Ƒ  Fixed; apply the link to the left and return 1 if the result is equal to
          its argument, 0 if not.
      Ɗ       Drei; combine the three links to the left into a monadic chain.
  ṠÞ              Sort the differences by their signs (negative, zero, positive).
     S            Take the sum of the differences, yielding 0 if and only if the
                  first digit is equal to the last.
    +             Add the sum to each difference.

JavaScript (ES6), 62 54 Bytes

Übernimmt die Eingabe als Zeichenfolge. Gibt einen Booleschen Wert zurück.

s=>s[-[...s].some(p=q=n=>q>(q=Math.sign(p-(p=n))))]==p

Probieren Sie es online!

Kommentiert

s =>                  // s = input string
  s[                  // we will eventually access either s[0] or s[-1]
    -[...s].some(     // depending on the result of this some()
      p = q =         // initialize p and q to non-numeric values
      n =>            // for each digit n:
        q > (         //   compare q with
          q =         //   the new value of q,
          Math.sign(  //   defined as the sign of
          p - (p = n) //   the difference between the current digit and the previous one
        ))            //   yield true if the previous q is greater than the new q
    )                 // s[-1] being undefined, a truhty some() will force the test to fail
  ] == p              // otherwise: test if the 1st digit s[0] is equal to the last digit p

JavaScript (ES6), 65 Byte

$0$$1$

s=>/N(,-\d+)*(,0)*[^0-]*$/.test([...s].map(p=v=>p-(p=v)))&p==s[0]

Probieren Sie es online!

Wie?

$[-9,9]$

[...s].map(p = v => p - (p = v))

Beispiel:

"234567992" --> [ NaN, -1, -1, -1, -1, -1, -2, 0, 7 ]

Dieses Array wird in eine Zeichenfolge umgewandelt, die Folgendes ergibt:

"NaN,-1,-1,-1,-1,-1,-2,0,7"

Wir wenden den folgenden regulären Ausdruck an:

 +-----------------------> the second 'N' of 'NaN'
 |    +------------------> a sequence of negative numbers
 |    |     +------------> a sequence of zeros
 |    |     |     +------> a sequence of positive numbers
 |    |     |     |  +---> end of string
 |    |     |     |  |
 |/¨¨¨¨¨¨\/¨¨¨\/¨¨¨¨\|
/N(,-\d+)*(,0)*[^0-]*$/

Schließlich testen wir auch, ob die letzte Ziffer pgleich der ersten Ziffer ist s[0].

Pyth, 16 Bytes

&SI_._MJ.+jQT!sJ

Probieren Sie die Testsuite aus .

          jQT          input in base 10
       J.+             J = differences: [3,1,4,1] -> [-2,3,-3]
    ._M                Signs of each element of J
   _                   Reverse the list
 SI                    and check if it is Invariant under Sorting.
                       If this is true, J consists of some positive numbers,
                         followed by some 0s, followed by some negative numbers,
                         which is what we want.
            !sJ        Now we check the other hill condition by ensuring
                         sum(differences) = 0; i.e. the first and last digit are equal.
&                      We take the logical AND of both conditions.

Jelly , 11 Bytes

DIµṠNṢƑaS¬$

Erläuterung:

D               Convert to a list of Digits.
 I              Increments; compute differences between successive elements.
  µ             Start new µonadic link.
   Ṡ              Find Ṡign of each increment
    N             then negate;
     ṢƑ           is the result invariant under Ṣorting?
                  If so, the increments consist of some positive numbers,
                     followed by some 0s, followed by some negative numbers,
                     which is what we want.
       a          Logical AND this result with
        S¬$       logical NOT of the Sum of the increments.
                  If the sum of the increments is zero, first and last digits are equal.

Probieren Sie es online!

Perl 6 , 39 Bytes

{.[0]==.tail&&[<=] $_ Z<=>.skip}o*.comb

Probieren Sie es online!

Erläuterung

{ ... }o.comb  # Split into digits and feed into block
.[0]==.tail    # First element equals last
&&             # and
     $_ Z<=>.skip  # Pairwise application of three-way comparator
[<=]           # Results never decrease

Python 2 , 114 112 Bytes

lambda n:all((n[0]==n[-1])*sorted(set(x))==list(x)[::d]for x,d in zip(n.split(max(n)*n.count(max(n)),1),[1,-1]))

Probieren Sie es online!

R , 65 Bytes

Nimmt Saiten. Übernahm die Idee, die Sortierinvarianz anhand der Pyth-Antwort zu überprüfen.

function(a)!sum(d<-diff(utf8ToInt(a)))&all(sort(k<-sign(d),T)==k)

Probieren Sie es online!

05AB1E , 19 17 13 12 Bytes

¥D.±Â{RQsO_*

-5 Bytes, indem Sie einen Port für die Pyth -Antwort von @lirtosiast erstellen .

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

¥           # Push the deltas of the digits of the (implicit) input
            #  i.e. 4588774 → [1,3,0,-1,0,-3]
 D          # Duplicate this list
  .±        # Get the sign of each
            #  [1,3,0,-1,0,-3] → [1,1,0,-1,0,-1]
    Â       # Bifurcate (short for DR: Duplicate and Reverse copy)
            #  i.e. [1,1,0,-1,0,-1] → [-1,0,-1,0,1,1]
     {      # Sort the copy
            #  i.e. [-1,0,-1,0,1,1] → [-1,-1,0,0,1,1]
      R     # Reverse it
            #  i.e. [1,1,0,0,-1,-1]
       Q    # And check if they are equal
            #  i.e. [1,1,0,-1,0,-1] and [1,1,0,0,-1,-1] → 0 (falsey)
s           # Swap to get the list of deltas again
 O          # Take the sum
            #  i.e. [1,3,0,-1,0,-3] → 0
  _         # And check if it's exactly 0
            #  0 → 1 (truthy)
*           # Check if both are truthy (and output implicitly)
            #  i.e. 0 and 1 → 0 (falsey)

Â{RQkann alternativ (Â{Qfür die gleiche Anzahl von Bytes verwendet werden, wobei (jedes Zeichen negiert wird: Probieren Sie es online aus .

J, 23 Bytes

[:((0=+/)**-:*/:*)2-/\]

Idee aus den Jelly-Antworten gestohlen. Ich wollte nur sehen, wie kurz ich es in J schaffen könnte.

Probieren Sie es online!

MATL , 12 Bytes

dZSd1<AGds~*

Probieren Sie es online!

Erläuterung

Die Eingabe ist eine Ziffernfolge. Ausgabe ist ein 1oder 0. Die Nummer 222222ist eine Schanzennummer nach diesem Programm. 2 Bytes gespart, indem Dennis 'Methode zur Überprüfung der Gleichheit der ersten und letzten Ziffer kopiert wurde.

d               % Takes the difference between digits
 ZS             % Calculate the sign. 
   d            % Take the difference again. 
    1<          % A number is a hill number if these differences are < 1.
      A         % Truthy iff above is all true OR if array is empty (necessary for short inputs)
       Gds      % Push the input, and sum all the differences.
          ~     % Negate
           *    % Multiply the two tests (=logical AND).

Python 2 , 53 Bytes

def f(s):x=map(cmp,s,s[1:]);s[:sorted(x)==x]!=s[-1]>_

Übernimmt die Eingabe als Zeichenfolge. Die Ausgabe erfolgt über das Vorhandensein oder Fehlen einer Ausnahme .

Probieren Sie es online!

Python 2 , 62 Bytes

lambda s:s[:eval('<='.join(map(str,map(cmp,s,s[1:]))))]==s[-1]

Übernimmt die Eingabe als Zeichenfolge und gibt einen Booleschen Wert zurück.

Probieren Sie es online!

Mathematica / Wolfram-Sprache, 69 64 Bytes

Funktion pur. Übernimmt die Eingabe als Ganzzahl und gibt Trueoder zurück False.

Sort[x=Sign@-Differences[y=IntegerDigits@#]]==x&&y[[1]]==Last@y&

Erläuterung:

Die erste Klausel prüft die "Hügeligkeit":

• IntegerDigits: Ermittelt die Ziffern einer Ganzzahl. Speichern in y.
• -Differences: Nehmen Sie aufeinanderfolgende Differenzen und Flip-Zeichen.
• Sign: Ersetzen Sie jeden Eintrag durch +1, wenn er positiv ist, 0, wenn er null ist, und -1, wenn er negativ ist. Speichern in x.
• Sort: Liste von +1, 0, -1 vom kleinsten zum größten sortieren. Vergleiche mit der ursprünglichen Liste in x.

Die zweite Klausel prüft, ob die erste und die letzte Ziffer gleich sind.

Ein Tipp für die Verfeinerung dieses Codes an @IanMiller.

Japt, 11 Bytes

Übernimmt die Eingabe als Ziffernfeld.

ä-
eUñg)«Ux

Probieren Sie es aus oder führen Sie alle Testfälle aus

             :Implicit input of digit array U
ä-           :Deltas
\n           :Reassign to U
 Uñ          :Sort U
   g         :  By signs
e   )        :Check for equality with U
     «       :Logical AND with the negation of
      Ux     :U reduced by addition

Retina 0.8.2 , 52 Bytes

.
$*1;$&$*1,
(1+),\1
,
^(1+);(,1+;)*(,;)*(1+,;)*\1,$

Probieren Sie es online! Link enthält Testfälle. Erläuterung:

.
$*1;$&$*1,

Wandle jede Ziffer zweimal in unär um, getrennt durch ;s und abgeschlossen durch ,s. Sie können sich das Ergebnis dann jedoch als die erste Ziffer vorstellen, a ;, dann alle Paare benachbarter Ziffern, die Ziffern jedes Paares getrennt durch ,und die Paare getrennt durch ;s, dann eine andere ;, dann die letzte Ziffer, dann ein Finale ,.

(1+),\1
,

Subtrahieren Sie die Paare benachbarter Ziffern. Dies lässt ;,;für gleiche Ziffern und 1s für ungleiche Ziffern auf der größeren Seite. (Dies könnte als Teil des folgenden regulären Ausdrucks erfolgen, aber das wäre natürlich nicht so golfen.)

^(1+);(,1+;)*(,;)*(1+,;)*\1,$

Passen Sie die erste Ziffer an, dann eine beliebige Anzahl von Paaren aufsteigender Ziffern, dann eine beliebige Anzahl von Paaren gleicher Ziffern, dann eine beliebige Anzahl von Paaren absteigender Ziffern, und passen Sie die erste Ziffer ganz am Ende erneut an.

Rot , 181 Bytes

func[n][m: last sort copy t: s: form n
parse t[opt[copy a to m(a: sort unique a)]copy b thru any m
opt[copy c to end(c: sort/reverse unique c)]](s = rejoin[a b c])and(s/1 = last s)]

Probieren Sie es online!

Besser lesbar:

f: func[n][
    t: s: form n                                    
    m: last sort copy t                             
    parse t [ opt [ copy a to m (a: sort unique a) ] 
              copy b thru any m
              opt [ copy c to end (c: sort/reverse unique c) ]
            ]
    (s = rejoin [ a b c ]) and (s/1 = last s)
]

Powershell, 77 Bytes

($x=-join("$($args|%{"-$_;$_"})"|iex))-match'^(-\d)+0*\d+$'-and$x[1]-eq$x[-1]

Weniger Golf-Testskript:

$f = {
                                           # $args = 1,2,3,3,3,2,1
$a=$args|%{"-$_;$_"}                       # "-1;1","-2;2","-3;3","-3;3","-3;3","-2;2","-1;1"
$d="$a"                                    # "-1;1 -2;2 -3;3 -3;3 -3;3 -2;2 -1;1"
$x=-join($d|Invoke-Expression)             # "-1-1-100111"
$x-match'^(-\d)+0*\d+$'-and$x[1]-eq$x[-1]  # $true or $false

}

@(
    ,($True , 1,2,3,2,1 )
    ,($True , 1,2,3,3,3,2,1 )
    ,($True , 9,9 )
    ,($True , 3 )
    ,($True , 2,3,4,5,6,7,9,9,2 )
    ,($False, 1,2,3,2 )
    ,($False, 7,7,8,8,9,6 )
    ,($False, 2,3,2,3,2 )
    ,($False, 4,5,5,6,6,5,5,4 )
    ,($False, 5,6,4,5 )
) | % {
    $expected,$a = $_
    $result = &$f @a
    "$($result-eq$expected): $result"
}

Ausgabe:

True: True
True: True
True: True
True: True
True: True
True: False
True: False
True: False
True: False
True: False

C # (Visual C # Interactive Compiler) , 161 Byte

s=>{var m=s.OrderBy(c=>c).Last();return s[0]==s.Last()&Enumerable.Range(1,s.Length-1).All(i=>i>s.LastIndexOf(m)?s[i-1]>s[i]:i>s.IndexOf(m)?m==s[i]:s[i-1]<s[i]);}

Probieren Sie es online!

Hier ist eine Übersicht, wie das funktioniert ...

1. Die Eingabe erfolgt in Form eines string
2. Finde die größte Ziffer
3. Stellen Sie sicher, dass die erste und die letzte Ziffer identisch sind
4. Stellen Sie sicher, dass die Ziffern nach dem letzten Auftreten der größten Ziffer abnehmen
5. Stellen Sie sicher, dass die Ziffern zwischen dem ersten und letzten Vorkommen der größten Ziffer der größten Ziffer entsprechen
6. Stellen Sie sicher, dass die Ziffern vor dem ersten Auftreten der größten Ziffer zunehmen

Python 3 , 114 Bytes

def f(r):
 l=[*r]
 for i in-1,0:
  while 1<len(l)and l[i]<l[(1,-2)[i]]:l.pop(i)
 return 2>len({*l})and r[0]==r[-1]

Probieren Sie es online!

Viel länger als einige Python 2-Lösungen, aber diese basiert auf Def und gefällt mir.

Ruby , 47 Bytes

->n{(r=n.each_cons(2).map{|a,b|a<=>b})==r.sort}

Probieren Sie es online!

Eingabe als Array von Ziffern, Ausgabe ist boolesch.