Un numero di collina è un numero che ha la stessa cifra nel primo e nell'ultimo , ma non è tutto. In un numero di collina, le prime cifre sono in costante aumento e le ultime cifre sono in netto calo. La cifra più grande può essere ripetuta .

Ecco un esempio di un numero di collina:

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

Questo non è :

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

Sfida

Dato un numero intero positivo, scrivi un programma completo o una funzione che restituisca verità per i numeri di collina ma falsi su altri valori.

Appunti:

• Input e output possono essere in qualsiasi formato ragionevole .
• Questo è code-golf, quindi vince la risposta più breve in ogni lingua!

Casi test

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

Gelatina , 8 byte

_ƝṠÞ+SƊƑ

Provalo online!

Come funziona

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

Accetta l'input come stringa. Restituisce un valore booleano.

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

Provalo online!

Commentate

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

Una soluzione che utilizza un'espressione regolare. Accetta l'input come stringa. Restituisce $0$ o $1$ .

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

Provalo online!

Come?

Per prima cosa convertiamo il numero in un elenco di differenze numeriche a coppie in $[-9,9]$ :

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

Esempio:

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

Questo array è forzato in una stringa, che fornisce:

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

Applichiamo la seguente espressione regolare:

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

Infine, testiamo anche se l'ultima cifra pè uguale alla prima cifra s[0].

Pyth, 16 byte

&SI_._MJ.+jQT!sJ

Prova la suite di test .

          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.

Gelatina , 11 byte

DIµṠNṢƑaS¬$

Spiegazione:

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.

Provalo online!

Perl 6 , 39 byte

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

Provalo online!

Spiegazione

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

Provalo online!

R , 65 byte

Prende stringhe. Ho preso l'idea per controllare l'invarianza dell'ordinamento dalla risposta Pyth.

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

Provalo online!

05AB1E , 19 17 13 12 byte

¥D.±Â{RQsO_*

-5 byte creando una porta di @lirtosiast risposta Pyth s' .

Provalo online o verifica tutti i casi di test .

Spiegazione:

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

Â{RQpuò in alternativa essere (Â{Qper lo stesso conteggio byte, dove (nega ogni segno: provalo online .

J, 23 byte

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

L'idea rubata dalle risposte della gelatina. Volevo solo vedere quanto potevo fare in J.

Provalo online!

MATL , 12 byte

dZSd1<AGds~*

Provalo online!

Spiegazione

L'input è una stringa di cifre. L'output è un 1o 0. Il numero 222222è un numero di collina secondo questo programma. Salvato 2 byte copiando il metodo di Dennis per verificare l'uguaglianza della prima e dell'ultima cifra.

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

Accetta l'input come stringa. L'output avviene tramite presenza o assenza di un'eccezione .

Provalo online!

Python 2 , 62 byte

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

Prende l'input come stringa e restituisce un valore booleano.

Provalo online!

Mathematica / Wolfram Language, 69 64 byte

Funzione pura. Accetta input come numero intero, restituisce Trueo False.

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

Spiegazione:

La prima clausola controlla la "pendenza":

• IntegerDigits: Ottieni cifre da un numero intero. Conservare in y.
• -Differences: Prende le differenze successive e capovolgi i segni.
• Sign: Sostituisci ogni voce con +1 se positivo, 0 se zero e -1 se negativo. Conservare in x.
• Sort: Ordina l'elenco di +1, 0, -1 dal più piccolo al più grande. Confronta con l'elenco originale in x.

La seconda clausola controlla se la prima e l'ultima cifra sono uguali.

Un suggerimento per @IanMiller per suggerimenti su come perfezionare questo codice.

Japt, 11 byte

Accetta input come una matrice di cifre.

ä-
eUñg)«Ux

Provalo o esegui tutti i casi di test

             :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,$

Provalo online! Il link include casi di test. Spiegazione:

.
$*1;$&$*1,

Converti ogni cifra in unaria due volte, separata da se ;terminata da ,s. Tuttavia, puoi pensare al risultato come alla prima cifra, a; , quindi tutte le coppie di cifre adiacenti, le cifre di ciascuna coppia separate da ,e le coppie separate da ;s, quindi un'altra ;, quindi l'ultima cifra, quindi una finale ,.

(1+),\1
,

Sottrai le coppie di cifre adiacenti. Questo lascia ;,;cifre uguali e 1s sul lato maggiore per cifre disuguali. (Questo potrebbe essere fatto come parte del regex seguente, ma ovviamente non sarebbe così da golf.)

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

Abbina la prima cifra, quindi qualsiasi numero di coppie di cifre ascendenti, quindi qualsiasi numero di coppie di cifre uguali, quindi qualsiasi numero di coppie di cifre decrescenti, quindi abbina nuovamente la prima cifra alla fine.

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

Provalo online!

Più leggibile:

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]

Script di test meno golfato:

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

Produzione:

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

C # (compilatore interattivo 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]);}

Provalo online!

Ecco una panoramica di come funziona ...

1. L'input ha la forma di a string
2. Trova la cifra più grande
3. Assicurarsi che la prima e l'ultima cifra siano uguali
4. Accertarsi che le cifre dopo l'ultima occorrenza della cifra più grande stiano diminuendo
5. Assicurarsi che le cifre tra la prima e l'ultima occorrenza della cifra più grande siano uguali alla cifra più grande
6. Accertarsi che le cifre prima che la prima occorrenza della cifra più grande aumenti

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]

Provalo online!

Molto più lungo di alcune soluzioni Python 2, ma questa è basata su def e mi piace.

Rubino , 47 byte

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

Provalo online!

Input come array di cifre, output è booleano.