Nomor bukit adalah angka yang dimiliki angka yang sama di bagian pertama & terakhir , tetapi bukan itu saja. Di nomor bukit angka pertama benar - benar meningkat , dan angka terakhir sangat menurun. Digit terbesar dapat diulang .

Berikut adalah contoh nomor bukit:

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

Ini adalah bukan :

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

Tantangan

Diberi bilangan bulat positif, tulis program lengkap atau fungsi yang mengembalikan kebenaran untuk nomor hill tetapi salah pada nilai-nilai lain.

Catatan:

• Input & output bisa masuk format apa pun yang masuk akal .
• Ini adalah kode-golf sehingga jawaban terpendek di setiap bahasa menang!

Uji Kasus

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

Jelly , 8 byte

_ƝṠÞ+SƊƑ

Cobalah online!

Bagaimana itu bekerja

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

Mengambil input sebagai string. Mengembalikan nilai Boolean.

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

Cobalah online!

Berkomentar

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

Solusi menggunakan ekspresi reguler. Mengambil input sebagai string. Mengembalikan $0$ atau $1$ .

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

Cobalah online!

Bagaimana?

Kami pertama-tama mengonversi nomor tersebut ke daftar perbedaan digit berpasangan di $[-9,9]$ :

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

Contoh:

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

Array ini dipaksa untuk sebuah string, yang memberikan:

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

Kami menerapkan ungkapan reguler berikut:

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

Akhirnya, kami juga menguji apakah digit terakhir psama dengan digit pertama s[0].

Pyth, 16 byte

&SI_._MJ.+jQT!sJ

Coba test suite .

          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.

Jeli , 11 byte

DIµṠNṢƑaS¬$

Penjelasan:

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.

Cobalah online!

Perl 6 , 39 byte

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

Cobalah online!

Penjelasan

{ ... }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 byte

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

Cobalah online!

R , 65 byte

Membawa string. Mengambil ide untuk memeriksa jenis invarian dari jawaban Pyth.

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

Cobalah online!

05AB1E , 19 17 13 12 byte

¥D.±Â{RQsO_*

-5 byte dengan menciptakan pelabuhan @lirtosiast 's Pyth jawabannya .

Cobalah secara online atau verifikasi semua kasus uji .

Penjelasan:

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

Â{RQalternatifnya bisa (Â{Quntuk byte-count yang sama, di mana (meniadakan setiap tanda: Cobalah secara online .

J, 23 byte

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

Ide dicuri dari jawaban Jelly. Hanya ingin melihat betapa singkatnya saya bisa sampai di J.

Cobalah online!

MATL , 12 byte

dZSd1<AGds~*

Cobalah online!

Penjelasan

Input adalah serangkaian digit. Output adalah a 1atau 0. Nomornya 222222adalah nomor bukit menurut program ini. Disimpan 2 byte dengan menyalin metode Dennis untuk memeriksa kesetaraan digit pertama dan terakhir.

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 byte

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

Mengambil input sebagai string. Output adalah melalui ada tidaknya pengecualian .

Cobalah online!

Python 2 , 62 byte

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

Mengambil input sebagai string dan mengembalikan Boolean.

Cobalah online!

Bahasa Mathematica / Wolfram, 69 64 byte

Fungsi murni. Mengambil input sebagai integer, mengembalikan Trueatau False.

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

Penjelasan:

Klausa pertama memeriksa "hilliness":

• IntegerDigits: Dapatkan digit dari integer. Simpan di y.
• -Differences: Ambil perbedaan bergantian dan flip sign.
• Sign: Ganti setiap entri dengan +1 jika positif, 0 jika nol, dan -1 jika negatif. Simpan di x.
• Sort: Urutkan daftar +1, 0, -1 dari terkecil hingga terbesar. Bandingkan dengan daftar asli di x.

Klausa kedua memeriksa apakah angka pertama dan terakhir sama.

Tip untuk @IanMiller untuk kiat menyempurnakan kode ini.

Japt, 11 byte

Mengambil input sebagai array angka.

ä-
eUñg)«Ux

Cobalah atau jalankan semua test case

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

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

Cobalah online! Tautan termasuk kasus uji. Penjelasan:

.
$*1;$&$*1,

Konversi setiap digit menjadi unary dua kali, dipisahkan oleh ;s dan diakhiri oleh ,s. Namun, Anda kemudian dapat menganggap hasilnya sebagai digit pertama, a ;, lalu semua pasangan digit yang berdekatan, digit masing-masing pasangan yang dipisahkan oleh ,dan pasangan yang dipisahkan oleh ;s, lalu yang lain; , lalu digit terakhir, lalu final ,.

(1+),\1
,

Kurangi pasangan angka yang berdekatan. Ini pergi;,; digit yang sama dan berada 1di sisi yang lebih besar untuk digit yang tidak sama. (Ini bisa dilakukan sebagai bagian dari regex berikut tetapi jelas itu tidak akan begitu golf.)

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

Cocokkan digit pertama, lalu jumlah pasangan dari digit naik, lalu berapa pun jumlah pasangan dari digit yang sama, lalu jumlah pasangan dari digit turun, lalu cocokkan digit pertama lagi di bagian paling akhir.

Merah , 181 byte

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

Cobalah online!

Lebih mudah dibaca:

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 byte

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

Skrip uji yang kurang golf:

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

Keluaran:

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

Cobalah online!

Berikut ini gambaran umum tentang cara kerjanya ...

1. Masukan dalam bentuk a string
2. Temukan digit terbesar
3. Pastikan digit pertama dan terakhir sama
4. Pastikan digit setelah kemunculan terakhir dari digit terbesar berkurang
5. Pastikan digit antara kemunculan pertama dan terakhir dari digit terbesar sama dengan digit terbesar
6. Pastikan digit sebelum kemunculan pertama digit terbesar meningkat

Python 3 , 114 byte

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]

Cobalah online!

Jauh lebih lama daripada beberapa solusi Python 2, tapi yang ini berbasis def dan saya menyukainya.

Ruby , 47 byte

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

Cobalah online!

Input sebagai array digit, output adalah boolean.