Số đồi là một số có cùng một chữ số ở đầu & cuối , nhưng đó không phải là tất cả. Trong một số đồi, các chữ số đầu tiên đang tăng nghiêm ngặt và các chữ số cuối cùng đang giảm nghiêm ngặt. Chữ số lớn nhất có thể được lặp lại .

Dưới đây là một ví dụ về số đồi:

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

Đây không phải là :

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

Thử thách

Cho một số nguyên dương, viết một chương trình đầy đủ hoặc một hàm trả về giá trị trung thực cho số đồi nhưng sai lệch trên các giá trị khác.

Ghi chú:

• Đầu vào và đầu ra có thể ở bất kỳ định dạng hợp lý .
• Đây là môn đánh gôn nên câu trả lời ngắn nhất trong mỗi ngôn ngữ sẽ thắng!

Các trường hợp thử nghiệm

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

Thạch , 8 byte

_ƝṠÞ+SƊƑ

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

Đưa đầu vào dưới dạng một chuỗi. Trả về giá trị Boolean.

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

Hãy thử trực tuyến!

Đã bình luận

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

Một giải pháp sử dụng một biểu thức thông thường. Đưa đầu vào dưới dạng một chuỗi. Trả về $0$ hoặc $1$ .

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

Hãy thử trực tuyến!

Làm sao?

Trước tiên, chúng tôi chuyển đổi số thành danh sách các khác biệt về chữ số theo cặp trong $[-9,9]$ :

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

Thí dụ:

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

Mảng này được ép buộc thành một chuỗi, cung cấp cho:

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

Chúng tôi áp dụng các biểu thức chính quy sau:

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

Cuối cùng, chúng tôi cũng kiểm tra xem chữ số cuối cùng pcó bằng chữ số đầu tiên không s[0].

Bình thường, 16 byte

&SI_._MJ.+jQT!sJ

Hãy thử bộ thử nghiệm .

          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.

Thạch , 11 byte

DIµṠNṢƑaS¬$

Giải trình:

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.

Hãy thử trực tuyến!

Perl 6 , 39 byte

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

Hãy thử trực tuyến!

Giải trình

{ ... }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]))

Hãy thử trực tuyến!

R , 65 byte

Mất dây. Lấy ý tưởng để kiểm tra tính bất biến từ câu trả lời của Pyth.

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

Hãy thử trực tuyến!

05AB1E , 19 17 13 12 byte

¥D.±Â{RQsO_*

-5 byte bằng cách tạo ra một cổng của @lirtosiast 's Pyth câu trả lời .

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

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

Â{RQcách khác có thể là (Â{Qcho cùng một số đếm byte, trong đó (phủ nhận từng dấu: Hãy thử trực tuyến .

J, 23 byte

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

Ý tưởng bị đánh cắp từ câu trả lời Jelly. Chỉ muốn xem tôi có thể làm nó ngắn đến mức nào trong J.

Hãy thử trực tuyến!

MATL , 12 byte

dZSd1<AGds~*

Hãy thử trực tuyến!

Giải trình

Đầu vào là một chuỗi các chữ số. Đầu ra là một 1hoặc0 . Số 222222này là một số đồi theo chương trình này. Đã lưu 2 byte bằng cách sao chép phương thức của Dennis để kiểm tra sự bằng nhau của các chữ số đầu tiên và cuối cùng.

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

Con trăn 2 , 53 byte

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

Đưa đầu vào dưới dạng một chuỗi. Đầu ra là thông qua sự hiện diện hoặc vắng mặt của một ngoại lệ .

Hãy thử trực tuyến!

Con trăn 2 , 62 byte

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

Lấy đầu vào dưới dạng một chuỗi và trả về Boolean.

Hãy thử trực tuyến!

Ngôn ngữ toán học / Wolfram, 69 64 byte

Chức năng thuần túy. Lấy đầu vào là một số nguyên, trả về Truehoặc False.

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

Giải trình:

Mệnh đề đầu tiên kiểm tra "độ dốc":

• IntegerDigits: Lấy chữ số từ số nguyên. Cửa hàng trong y.
• -Differences: Lấy sự khác biệt liên tiếp và dấu hiệu lật.
• Sign: Thay thế mỗi mục nhập bằng +1 nếu dương, 0 nếu 0 và -1 nếu âm. Lưu trữ trongx .
• Sort: Sắp xếp danh sách +1, 0, -1 từ nhỏ nhất đến lớn nhất. So sánh với danh sách ban đầu trongx .

Mệnh đề thứ hai kiểm tra xem các chữ số đầu tiên và cuối cùng có bằng nhau không.

Mẹo về @IanMiller cho lời khuyên về việc tinh chỉnh mã này.

Japt, 11 byte

Đưa đầu vào dưới dạng một mảng chữ số.

ä-
eUñg)«Ux

Hãy thử nó hoặc chạy tất cả các trường hợp thử nghiệm

             :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

Võng mạc 0.8.2 , 52 byte

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

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Giải trình:

.
$*1;$&$*1,

Chuyển đổi mỗi chữ số thành unary hai lần, cách nhau bởi ;s và kết thúc bằng ,s. Tuy nhiên, sau đó bạn có thể nghĩ kết quả là chữ số đầu tiên, a ;, sau đó là tất cả các cặp chữ số liền kề, chữ số của mỗi cặp cách nhau ,và các cặp cách nhau bởi ;s, sau ;đó là chữ số cuối cùng, sau đó là chữ số cuối cùng ,.

(1+),\1
,

Trừ các cặp chữ số liền kề. Điều này để lại ;,;các chữ số bằng nhau và 1s ở phía lớn hơn cho các chữ số không bằng nhau. (Điều này có thể được thực hiện như là một phần của regex sau đây nhưng rõ ràng điều đó sẽ không gây khó chịu cho bạn.)

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

Ghép chữ số đầu tiên, sau đó bất kỳ số cặp chữ số tăng dần, sau đó bất kỳ số cặp chữ số bằng nhau, sau đó bất kỳ số cặp chữ số giảm dần, sau đó khớp lại chữ số đầu tiên ở cuối.

Màu đỏ , 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)]

Hãy thử trực tuyến!

Dễ đọc hơn:

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]

Kịch bản kiểm tra ít chơi gôn hơn:

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

Đầu ra:

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

C # (Trình biên dịch tương tác Visual C #) , 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]);}

Hãy thử trực tuyến!

Dưới đây là tổng quan về cách thức hoạt động của nó ...

1. Đầu vào ở dạng string
2. Tìm chữ số lớn nhất
3. Đảm bảo các chữ số đầu tiên và cuối cùng giống nhau
4. Đảm bảo các chữ số sau lần xuất hiện cuối cùng của chữ số lớn nhất đang giảm
5. Đảm bảo các chữ số giữa lần xuất hiện đầu tiên và lần xuất hiện cuối cùng của chữ số lớn nhất bằng chữ số lớn nhất
6. Đảm bảo các chữ số trước khi xuất hiện đầu tiên của chữ số lớn nhất đang tăng

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]

Hãy thử trực tuyến!

Dài hơn một số giải pháp Python 2, nhưng giải pháp này dựa trên def và tôi thích nó.

Ruby , 47 byte

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

Hãy thử trực tuyến!

Đầu vào là mảng các chữ số, đầu ra là boolean.