Tepe numarası, ilk ve sonda aynı rakama sahip bir sayıdır , ancak hepsi bu kadar değildir. Bir tepe numarasında ilk basamaklar kesinlikle artıyor ve son basamaklar kesinlikle azalıyor. En büyük rakam tekrarlanabilir .

İşte bir tepe numarası örneği:

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

Bu değil :

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

Meydan okuma

Olumlu bir tamsayı verildiğinde, tam bir program veya tepe sayıları için doğruluk, ancak diğer değerler üzerinde yanlışlık veren bir işlev yazın.

Notlar:

• Giriş ve çıkış herhangi bir makul formatta olabilir .
• Bu kod golf çok kısa sürede her dilde cevap kazanır!

Test Durumları

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

Jöle , 8 bayt

_ƝṠÞ+SƊƑ

Çevrimiçi deneyin!

Nasıl çalışır

_ƝṠÞ+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 bayt

Girişi dize olarak alır. Bir Boolean değeri döndürür.

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

Çevrimiçi deneyin!

Yorumlananlar

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 bayt

Düzenli bir ifade kullanan bir çözüm. Girişi dize olarak alır. döndürür$0$$1$ .

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

Çevrimiçi deneyin!

Nasıl?

$[-9,9]$ :

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

Misal:

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

Bu dizi şu dizeye zorlanır:

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

Aşağıdaki normal ifadeyi uyguluyoruz:

 +-----------------------> 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-]*$/

Son olarak, son basamağın pilk basamağa eşit olup olmadığını da test ediyoruz s[0].

Pyth, 16 bayt

&SI_._MJ.+jQT!sJ

Test paketini deneyin .

          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.

Jöle , 11 bayt

DIµṠNṢƑaS¬$

Açıklama:

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.

Çevrimiçi deneyin!

Perl 6 , 39 bayt

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

Çevrimiçi deneyin!

açıklama

{ ... }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 , 114112 bayt

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

Çevrimiçi deneyin!

R , 65 bayt

Dizeleri alır. Pyth cevabından sıralama değişmezliğini kontrol etme fikrini aldı.

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

Çevrimiçi deneyin!

05AB1E , 19 17 13 12 bayt

¥D.±Â{RQsO_*

-5 bayt @lirtosiast 's Pyth cevap portu oluşturarak .

Çevrimiçi deneyin veya tüm test senaryolarını doğrulayın .

Açıklama:

¥           # 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)

Â{RQalternatif olarak (Â{Q, (her bir işareti reddeden aynı bayt sayısı için olabilir : Çevrimiçi olarak deneyin .

J, 23 bayt

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

Jelly cevaplarından çalınan fikir. Sadece J'de ne kadar kısa yapabileceğimi görmek istedim.

Çevrimiçi deneyin!

MATL , 12 bayt

dZSd1<AGds~*

Çevrimiçi deneyin!

açıklama

Girdi bir basamak dizesidir. Çıktı a 1veya 0. Sayısı 222222, bu programa göre, bir tepe sayıdır. Dennis'in ilk ve son basamakların eşitliğini kontrol etme yöntemini kopyalayarak 2 bayt kaydetti.

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 bayt

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

Girişi dize olarak alır. Çıktı, bir istisnanın varlığı veya yokluğu yoluyla gerçekleşir .

Çevrimiçi deneyin!

Python 2 , 62 bayt

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

Girdiyi dize olarak alır ve bir Boolean döndürür.

Çevrimiçi deneyin!

Mathematica / Wolfram Dili, 69 64 bayt

Saf fonksiyon. Girdiyi tamsayı olarak alır, Trueveya döndürür False.

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

Açıklama:

İlk fıkra "tepeliği" kontrol eder:

• IntegerDigits: Tamsayıdan rakam alın. İçinde saklayın y.
• -Differences: Art arda gelen farklar ve çevirme işaretleri alın.
• Sign: Her girişi pozitifse +1, sıfırsa 0 ve negatifse -1 ile değiştirin. İçinde saklayın x.
• Sort: En küçükten en büyüğe +1, 0, -1 listesini sıralayın. İçindeki orijinal listeyle karşılaştırın x.

İkinci fıkra, ilk ve son basamakların eşit olup olmadığını kontrol eder.

Bu kodu düzeltmekle ilgili ipuçları için @IanMiller'e şapka ucu.

Japt, 11 bayt

Girdiyi rakam dizisi olarak alır.

ä-
eUñg)«Ux

Deneyin veya tüm test senaryolarını çalıştırın

             :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 bayt

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

Çevrimiçi deneyin! Bağlantı, test senaryolarını içerir. Açıklama:

.
$*1;$&$*1,

Her basamağı ;s ile ayrılmış ve s ile biten iki kez tekli olarak dönüştürün ,. Ancak, sonucu daha sonra ilk basamak, a ;, sonra tüm bitişik basamak çiftleri, her çiftin basamakları ve birbirinden ayrılmış ,çiftler ;s, sonra bir başkası ;, sonra son basamak, sonra bir son olarak düşünebilirsiniz ,.

(1+),\1
,

Subtract the pairs of adjacent digits. This leaves ;,; for equal digits and 1s on the greater side for unequal digits. (This could be done as part of the following regex but obviously that wouldn't be so golfy.)

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

Match the first digit, then any number of pairs of ascending digits, then any number of pairs of equal digits, then any number of pairs of descending digits, then match the first digit again at the very end.

Kırmızı , 181 bayt

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

Çevrimiçi deneyin!

Daha okunabilir:

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 bayt

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

Daha az golf test senaryosu:

$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"
}

Çıktı:

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

C # (Visual C # Etkileşimli Derleyici) , 161 bayt

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]);}

Çevrimiçi deneyin!

İşte bunun nasıl çalıştığına genel bir bakış ...

1. Girdi bir string
2. En büyük rakamı bulun
3. İlk ve son basamakların aynı olduğundan emin olun
4. En büyük rakamın son tekrarlanmasından sonra rakamların azaldığından emin olun
5. Ensure digits between the first and last occurrence of the largest digit are equal to the largest digit
6. Ensure digits before the first occurrence of the largest digit are increasing

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]

Try it online!

Way longer than some Python 2 solutions, but this one is def-based and I like it.

Ruby, 47 bytes

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

Try it online!

Input as array of digits, output is boolean.