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

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

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)

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

05AB1E , 19 17 13 12 바이트

¥D.±Â{RQsO_*

@lirtosiast 의 Pyth 응답 포트를 생성하여 -5 바이트 .

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 .

설명:

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

Â{RQ또는 각 (Â{Q바이트를 (무효화 하는 동일한 바이트 수일 수도 있습니다 . 온라인으로 시도하십시오 .

J, 23 바이트

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

젤리 답변에서 도난 아이디어. J에서 얼마나 짧게 만들 수 있는지보고 싶었습니다.

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

MATL , 12 바이트

dZSd1<AGds~*

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

설명

입력은 문자열입니다. 출력은 1또는 0입니다. 222222이 프로그램에 따른 숫자 는 언덕입니다. 첫 번째 숫자와 마지막 숫자가 같은지 확인하기 위해 Dennis의 방법을 복사하여 2 바이트를 절약했습니다.

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

파이썬 2 , 53 바이트

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

입력을 문자열로받습니다. 출력은 예외 유무를 통해 이루어 집니다.

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

파이썬 2 , 62 바이트

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

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

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

Mathematica / Wolfram 언어, 69 64 바이트

순수한 기능. 입력을 정수로 취 True하거나 또는를 반환합니다 False.

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

설명:

첫 번째 절은 "고칠 음"을 확인합니다.

• IntegerDigits: 정수에서 숫자를 가져옵니다. 에 저장하십시오 y.
• -Differences: 연속적인 차이와 뒤집기 기호를 사용하십시오.
• Sign: 각 항목을 양수이면 +1, 0이면 0, 음수이면 -1로 바꿉니다. 에 저장하십시오 x.
• Sort: +1, 0, -1의 목록을 최소에서 최대로 정렬합니다. 의 원본 목록과 비교하십시오 x.

두 번째 절은 첫 번째 숫자와 마지막 숫자가 같은지 확인합니다.

이 코드를 수정하는 방법에 대한 팁은 @IanMiller의 팁입니다.

apt, 11 바이트

숫자 배열로 입력을받습니다.

ä-
eUñg)«Ux

사용해 보거나 모든 테스트 사례를 실행하십시오.

             :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

망막 0.8.2 , 52 바이트

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

온라인으로 사용해보십시오!링크에는 테스트 사례가 포함됩니다. 설명:

.
$*1;$&$*1,

;s로 구분되고 s로 끝나는 각 숫자를 단항으로 두 번 변환합니다 ,. 그러나 결과는 첫 번째 숫자, a ;, 모든 인접한 숫자 쌍, 각 쌍의 숫자 ,가 ;s로 구분되고 s로 구분되고 다른 ;숫자, 마지막 숫자, 마지막 으로 생각할 수 있습니다 ,.

(1+),\1
,

인접한 숫자 쌍을 뺍니다. 이것은 ;,;같은 숫자를 남기고 1더 큰 쪽은 같지 않은 숫자를 남깁니다 . (이것은 다음 정규 표현식의 일부로 수행 될 수 있지만 분명히 그렇게 골프는 아닙니다.)

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

첫 번째 숫자, 오름차순 숫자 쌍, 동일한 숫자 쌍 쌍, 내림차순 숫자 쌍을 일치시킨 다음 맨 처음 숫자를 다시 일치시킵니다.

빨강 , 181 바이트

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

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

더 읽기 쉬운 :

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

파워 쉘, 77 바이트

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

덜 골프 테스트 스크립트 :

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

산출:

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

C # (Visual C # 대화식 컴파일러) 161 바이트

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

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

작동 방식에 대한 개요는 다음과 같습니다.

1. 입력은 string
2. 가장 큰 숫자 찾기
3. 첫 번째와 마지막 숫자가 동일한 지 확인하십시오
4. 가장 큰 숫자가 마지막으로 표시된 후 숫자가 감소하는지 확인하십시오
5. 가장 큰 숫자의 첫 번째와 마지막 숫자 사이의 숫자가 가장 큰 숫자와 같아야합니다
6. 가장 큰 숫자가 처음 표시되기 전에 숫자를 확인하십시오

파이썬 3 , 114 바이트

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]

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

일부 Python 2 솔루션보다 길지만이 기반은 def 기반이며 마음에 듭니다.

루비 , 47 바이트

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

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

숫자 배열로 입력되고 출력은 부울입니다.