이 번호는 언덕 번호입니까? 수의 예는 다음과

언덕 수는 첫 번째와 마지막 숫자가 같은 숫자 이지만 그게 전부는 아닙니다. 언덕 수에서 첫 번째 숫자는 엄격하게 증가 하고 마지막 숫자는 엄격하게 감소합니다. 최대 자릿수를 반복 할 수 있습니다 .

언덕 수의 예는 다음과 같습니다.

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

이것은 아닙니다 :

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

도전

양의 정수가 주어지면 전체 프로그램 또는 언덕 수에 대해서는 진실을 반환하지만 다른 값에는 거짓을 반환하는 함수를 작성하십시오.

노트:

  • 입력 및 출력은 임의의 합리적인 형식 일 수 있습니다 .
  • 이것은 이므로 각 언어에서 가장 짧은 대답이 승리합니다!

테스트 사례

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



답변

젤리 , 8 바이트

_ƝṠÞ+SƊƑ

온라인으로 사용해보십시오!

작동 원리

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


답변

자바 스크립트 (ES6), 62 54 바이트

입력을 문자열로받습니다. 부울 값을 반환합니다.

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

온라인으로 사용해보십시오!

댓글

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

자바 스크립트 (ES6), 65 바이트

정규식을 사용하는 솔루션. 입력을 문자열로받습니다.

0

또는

1

반환합니다 .

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

온라인으로 사용해보십시오!

어떻게?

우리는 처음에 페어 자리의 차이점 목록에 번호를 변환

[9,9]

:

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

예:

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

이 배열은 문자열로 강제 변환되어 다음을 제공합니다.

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

다음 정규식을 적용합니다.

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

마지막으로, 마지막 숫자 p가 첫 번째 숫자와 같은지 테스트합니다 s[0].


답변

Pyth, 16 바이트

&SI_._MJ.+jQT!sJ

테스트 스위트를 사용해보십시오 .

          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.


답변

젤리 , 11 바이트

DIµṠNṢƑaS¬$

설명:

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.

온라인으로 사용해보십시오!


답변

펄 6 , 39 바이트

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

온라인으로 사용해보십시오!

설명

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


답변

파이썬 2 , 114 112 바이트

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

온라인으로 사용해보십시오!


답변

R , 65 바이트

문자열을 취합니다. Pyth 답변과 정렬 불일치를 확인하는 아이디어를 얻었습니다.

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

온라인으로 사용해보십시오!