(inspiré par ce défi sur Puzzling - les SPOILERS pour ce puzzle sont ci-dessous, alors arrêtez de lire ici si vous voulez résoudre ce puzzle par vous-même!)

Si une lettre d'un mot apparaît alphabétiquement plus tard que la lettre précédente du mot, nous appelons cela une élévation entre les deux lettres. Sinon, même si c'est la même lettre , ça s'appelle une chute .

Par exemple, le mot ACEa deux montées ( Avers Cet Cvers E) et aucune chute, tandis qu'il THEa deux chutes ( Tvers Het Hvers E) et aucune montée.

Nous appelons un mot cahoteux si la séquence de montées et de chutes alterne. Par exemple, BUMPva monter ( Bà U), tomber ( Uà M), monter ( Mà P). Notez que la première séquence n'a pas besoin d'être une montée - BALDva chute-montée-chute et est également cahoteuse.

Le défi

Étant donné un mot, affichez s'il s'agit ou non de Bumpy.

Contribution

• Un mot (pas nécessairement un mot du dictionnaire) composé uniquement de lettres ( [A-Z]ou [a-z]) alphabétiques ASCII , dans n'importe quel format approprié .
• Votre choix si l'entrée est entièrement en majuscules ou en minuscules, mais elle doit être cohérente.
• Le mot comptera au moins 3 caractères.

Sortie

Une valeur truey / falsey pour savoir si le mot d'entrée est Bumpy (véridique) ou non Bumpy (falsey).

Les règles

• Un programme complet ou une fonction sont acceptables.
• Les failles standard sont interdites.
• Il s'agit de code-golf, donc toutes les règles de golf habituelles s'appliquent et le code le plus court (en octets) l'emporte.

Exemples

Vérité:

ABA
ABB
BAB
BUMP
BALD
BALDY
UPWARD
EXAMINATION
AZBYCXDWEVFUGTHSIRJQKPLOMN

Falsey:

AAA
BBA
ACE
THE
BUMPY
BALDING
ABCDEFGHIJKLMNOPQRSTUVWXYZ

Classements

Voici un extrait de pile permettant de générer à la fois un classement régulier et un aperçu des gagnants par langue.

Pour vous assurer que votre réponse apparaît, commencez votre réponse par un titre, en utilisant le modèle Markdown suivant:

# Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores en les effaçant. Par exemple:

# Ruby, <s>104</s> <s>101</s> 96 bytes

Si vous souhaitez inclure plusieurs numéros dans votre en-tête (par exemple, parce que votre score est la somme de deux fichiers ou si vous souhaitez répertorier séparément les pénalités d'indicateur d'interprétation), assurez-vous que le score réel est le dernier numéro de l'en-tête:

# Perl, 43 + 2 (-p flag) = 45 bytes

Vous pouvez également faire du nom de la langue un lien qui apparaîtra ensuite dans l'extrait de classement:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

var QUESTION_ID=93005,OVERRIDE_USER=42963;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

MATL, 4 octets

d0>d

Explication:

d     % Implicitly take input. Take difference between each element
 0>   % Check whether diff's are positive. Should result in [0 1 0 1 ...] pattern.
   d  % Again take the difference. Any consecutive rises or falls results in a 
      % difference of 0, which is a falsy value in MATL

Ceci est ma première entrée MATL, donc je me demande quelle amélioration il peut y avoir de ce port naïf de ma tentative MATLAB / Octave (qui serait @(a)all(diff(diff(a)>0))). Notez que le alln'est pas nécessaire car tout zéro rend un tableau faux, donc il n'y Aen a pas dans le port MATL.

JavaScript (ES6), 75 69 63 46 43 octets

Enregistré 3 octets grâce à Neil:

f=([c,...s])=>s[1]?c<s[0]^s[0]<s[1]&&f(s):1

Déstructuration du paramètre de chaîne au lieu de s.slice(1).

f=s=>s[2]?s[0]<s[1]^s[1]<s[2]&&f(s.slice(1)):1

Ce qui s'est passé étape par étape de la solution précédente:

f=(s,i=0,a=s[i++]<s[i])=>s[i+1]&&(b=a^(a=s[i]<s[i+1]))?f(s,i):b // (63) Original
f=(s,i=0,a=s[i++]<s[i])=>s[i+1]&&(b=a^(s[i]<s[i+1]))?f(s,i):b   // (61) No point in reassigning `a`, it's not used again
f=(s,i=0,a=s[i++]<s[i])=>s[i+1]&&(b=a^s[i]<s[i+1])?f(s,i):b     // (59) Remove unnecessary parentheses
f=(s,i=0)=>s[i+2]&&(b=s[i++]<s[i]^s[i]<s[i+1])?f(s,i):b         // (55) `a` is now just a waste of bytes
f=(s,i=0)=>s[i+2]?(b=s[i++]<s[i]^s[i]<s[i+1])?f(s,i):b:1        // (56) Rearrange conditional expressions to allow for more golfing
f=(s,i=0)=>s[i+2]?(b=s[i++]<s[i]^s[i]<s[i+1])&&f(s,i):1         // (55) Rearrange conditional expression
f=(s,i=0)=>s[i+2]?(s[i++]<s[i]^s[i]<s[i+1])&&f(s,i):1           // (53) `b` is now also a waste of bytes
f=(s,i=0)=>s[i+2]?s[i++]<s[i]^s[i]<s[i+1]&&f(s,i):1             // (51) Remove unnecessary parentheses
f=s=>s[2]?s[0]<s[1]^s[1]<s[2]&&f(s.slice(1)):1                  // (46) Use `s.slice(1)` instead of `i`

f=(s,i=0,a=s[i++]<s[i])=>s[i+1]&&(b=a^(a=s[i]<s[i+1]))?f(s,i):b

69 octets:

f=(s,i=0,a=s[i++]<s[i])=>i+1<s.length&&(b=a^(a=s[i]<s[i+1]))?f(s,i):b

75 octets:

f=(s,a=s[0]<s[1])=>{for(i=1;i+1<s.length&&(b=a^(a=s[i++]<s[i])););return b}

Toutes les lettres d'un mot doivent avoir la même casse.

LabVIEW, 36 octets équivalents

Golfé en utilisant des équivalences logiques:

Ungolfed:

Nous convertissons d'abord en minuscules, puis en tableau d'octets. Coupez le premier élément du tableau d'octets car il n'a pas de précédent. Ensuite, pour chaque élément du tableau, vérifiez s'il est supérieur au précédent (le caractère U8 est mappé en ASCII comme prévu) et stockez le résultat pour la prochaine itération, ainsi que dans un tableau pour afficher les bosses globales. Si les vérifications booléennes actuelles et antérieures sont égales, nous terminons la boucle et ce n'est pas cahoteux. Sinon, c'est cahoteux!

Python, 56 octets

lambda s:all((x<y)^(y<z)for x,y,z in zip(s,s[1:],s[2:]))

Tous les cas de test sont à idéone

Zips à travers des triplets de caractères dans s et teste que tous ces triplets ont des paires gauche et droite avec différentes propriétés de montée / descente.
Fonctionne soit en majuscules soit en minuscules.

Rubis, 57 48 octets

S'attend à ce que l'entrée soit entièrement en majuscules.

->s{!s.gsub(/.(?=(.)(.))/){($&<$1)^($1<$2)}[?f]}

Voir sur repl.it: https://repl.it/D7SB

Explication

L'expression régulière /.(?=(.)(.))/correspond à chaque caractère suivi de deux autres caractères. (?=...)est une anticipation positive, ce qui signifie que nous faisons correspondre les deux caractères suivants, mais ne les "consommons" pas dans le cadre de la correspondance. À l'intérieur des accolades, se $&trouve le texte correspondant - le premier caractère des trois - et $1et $2sont les caractères capturés à l'intérieur de l'antichambre. En d'autres termes, si la chaîne est "BUMPY", elle correspondra d'abord "B"(et la mettra $&) et capturera "U"et "M"(et les mettra $1et $2). Ensuite , il correspondra "U"et la capture "M"et "P", et ainsi de suite.

À l'intérieur du bloc, nous vérifions si la première paire de caractères ( $&et $1) est une montée et la seconde ( $1et $2) est une chute ou vice versa, un peu comme la plupart des autres réponses. Cette ^expression renvoie trueou false, qui est convertie en chaîne et insérée à la place de la correspondance. En conséquence, notre exemple "BUMPY"devient ceci:

"truetruefalsePY"

Puisque nous savons que l'entrée est entièrement en majuscules, nous savons "f"qu'elle ne se produira que dans le cadre de "false"et !result[?f]nous donnera notre réponse.

C #, 64 63 55 octets

unsafe bool B(char*s)=>1>s[2]||*s<s[1]!=*++s<s[1]&B(s);

-8 octets des suggestions de Scepheo

Il s'agit d'un portage de la solution Hedi vers C #. J'ai également trouvé une solution récursive, mais la récursivité n'était pas aussi bonne. Ma solution originale est ci-dessous.

Mon C # d'origine, 96 94 91 octets

unsafe bool B(char*s,bool f=1>0,int i=0)=>1>s[1]||(s[0]<s[1]?f:1>i?!(f=!f):!f)&B(s+1,!f,1);

-2 octets en utilisant 1>0au lieu de true.

-3 octets des suggestions de Scepheo pour la solution de port ci-dessus

S'appelle récursivement vérifier que l'alternance montante / descendante alterne à chaque fois.

Ungolfed:

// unsafe in order to golf some bytes from string operations.
// f alternates with each recursive call
// i is 0 for the first call, 1 for all subsequent calls
unsafe bool B(char* s, bool f = 1 > 0, int i = 0) =>
    1 > s[1] ? 1 > 0// (instead of 1 == s.Length) check if s[1] = NULL, and return true.
    : (
        s[0] < s[1] ? f // Rising, so use f...
        : // Else falling
            1 > i ? !(f=!f) // But this is the first call, so use true (but flip f)...
            : !f // Not first call, so use !f...
    )
    & B(s+1, !f, 1) // ...AND the previous value with a recursive call
                    // s+1 instead of s.Substring(1)
;

C 59 octets

r;f(s)char*s;{for(r=0;r=*s?~r&1<<(*s>=*++s):0;);return!*s;}

Gelée , 6 octets

OI>0IẠ

Basé sur la réponse de @sanchises .

Essayez-le en ligne! ou Vérifiez tout.

Explication

OI>0IẠ  Input: string S
O       Convert each char in S to an ordinal
 I      Get the increments between each pair
  >0    Test if each is positive, 1 if true else 0
    I   Get the increments between each pair
     Ạ  Test if the list doesn't contain a zero, 1 if true else 0

JavaScript (ES6), 65 octets

s=>[...s].map(C=>(c?(R=c<C,i++?t&=r^R:0,r=R):t=1,c=C),c=r=i="")|t

.mapn'est certainement pas la meilleure solution .

Python 2, 88 octets

Solution simple.

s=input()
m=map(lambda x,y:y>x,s[:-1],s[1:])
print all(x-y for x,y in zip(m[:-1],m[1:]))

Essayez-le en ligne

Si les mêmes lettres consécutives n'étaient ni une montée ni une chute, la solution serait de 79 octets:

s=input()
m=map(cmp,s[:-1],s[1:])
print all(x-y for x,y in zip(m[:-1],m[1:]))

Perl, 34 octets

Comprend +3 pour -p(le code contient 'donc -ene peut pas être utilisé)

Donnez une entrée en majuscule sur STDIN:

bump.pl <<< AAA

bump.pl

#!/usr/bin/perl -p
s%.%$&.z lt$'|0%eg;$_=!/(.)\1./

Python, 51 octets

g=lambda a,b,c,*s:((a<b)^(b<c))*(s==()or g(b,c,*s))

Prend entrée comme g('B','U','M','P')et sorties 1ou 0.

Utilise le déballage des arguments pour prendre les trois premières lettres et vérifier si les deux premiers se comparent différemment des deux autres. Ensuite, revient sur le reste, en utilisant la multiplication pour and.

Gelée , 6 à 5 octets

-1 octet grâce à @Dennis (utilisez une réduction cumulative)

<2\IẠ

Tous les cas de test sont sur TryItOnline

Comment?

<2\IẠ - main link takes an argument, s,    e.g. "BUMP"    or "BUMPY"
<    - less than comparison (a dyad)
 2   - literal 2 (a nilad)
  \  - n-wise overlapping reduction when preceded by a dyad-nilad chain
       (i.e. reduce the list by pairs with less than)
                                           e.g. [1,0,1]   or [1,0,1,1]
   I  - consecutive differences,           e.g. [-1,1]    or [-1,1,0]
    Ạ - All, 0 if any values are 0 else 1, e.g. 1         or 0

Fonctionne soit en majuscules soit en minuscules.

Japt, 8 octets

Uä> ä- e

Testez-le en ligne!

Comment ça marche

Uä> ä- e  // Implicit: U = input string
Uä>       // Map each pair of chars X, Y in U to X > Y.
    ä-    // Map each pair of items in the result to X - Y.
          // If there are two consecutive rises or falls, the result contains a zero.
       e  // Check that every item is truthy (non-zero).
          // Implicit: output last expression

C # 105 104 Octets

bool f(char[]x){int t=1;for(int i=2,p=x[1],f=x[0]-p>>7;i<x.Length;)f^=t&=p<(p=x[i++])?1-f:f;return t>0;}

105 octets Solution:

bool f(char[]x){bool t=1>0,f=x[0]<x[1];for(int i=2,p=x[1];i<x.Length;)f^=t&=p<(p=x[i++])?!f:f;return t;}

Essayez-le en ligne

L'utilisation d'un tableau de caractères a sauvé un octet car l'espace peut être omis après les crochets. f(string x)contref(char[]x)

C'est 101 octets si je peux retourner un int 1/0 au lieu de bool true / false

int f(char[]x){int t=1;for(int i=2,p=x[1],f=x[0]-p>>7;i<x.Length;)f^=t&=p<(p=x[i++])?1-f:f;return t;}

Haskell, 52 octets

f x=and$g(/=)$g(>)x
  where g h y=zipWith h(tail y)y

Je soupçonne que je pourrais obtenir un morceau plus petit si je réussissais à me débarrasser de la construction "où", mais je suis probablement coincé avec zipWith.

Cela fonctionne en faisant une liste des hausses (Vrai) et des chutes (Faux), puis en faisant une liste de si les entrées adjacentes dans cette liste sont différentes

Il s'agit de ma première tentative sur l'un d'entre eux, je vais donc passer par mon processus de réflexion au cas où je me serais horriblement trompé quelque part.

Version non golfée (168 octets)

isBumpy :: [Char] -> Bool
isBumpy input = and $ areBumps $ riseFall input
  where
    riseFall ax@(x:xs) = zipWith (>) xs ax
    areBumps ax@(x:xs) = zipWith (/=) xs ax

Raccourcir les noms, supprimer les informations de type (100 octets)

f x = and $ g $ h x
  where
    h ax@(x:xs) = zipWith (>) xs ax
    g ax@(x:xs) = zipWith (/=) xs ax

Déplacer h dans la fonction principale car elle n'est utilisée qu'une seule fois (86 octets)

f ax@(x:xs) = and $ g $ zipWith (>) xs ax
  where
    g ax@(x:xs) = zipWith (/=) xs ax

Sachez que areBumps et riseFall sont assez similaires à l'abstrait (73 octets)

f x  = and $ g (/=) $ g (>) x
  where
    g h ya@(y:ys) = zipWith h ys ya

Notez que (tail y) est plus court que ya @ (y: ys) (70 octets)

f x  = and $ g (/=) $ g (>) x
  where
    g h y = zipWith h (tail y) y

Ranger; supprimer les espaces inutiles (52 octets)

f x=and$g(/=)$g(>)x
  where g h y=zipWith h(tail y)y

Java 7, 157 153 150 125 125 117 octets

int c(char[]z){for(int i=2,a,b,c;i<z.length;i++)if(((a=z[i-1])<(c=z[i])&(b=z[i-2])<a)|(a>=c&b>=a))return 0;return 1;}

Cas non testés et testés:

Essayez ici.

class M{
  static int c(char[] z){
    for(int i = 2, a, b, c; i < z.length; i++){
      if(((a = z[i-1]) < (c = z[i]) & (b = z[i-2]) < a) | (a >= c & b >= a)){
        return 0; //false
      }
    }
    return 1; //true
  }

  public static void main(String[] a){
    System.out.print(c("ABA".toCharArray()) + ", ");
    System.out.print(c("ABB".toCharArray()) + ", ");
    System.out.print(c("BAB".toCharArray()) + ", ");
    System.out.print(c("BUMP".toCharArray()) + ", ");
    System.out.print(c("BALD".toCharArray()) + ", ");
    System.out.print(c("BALDY".toCharArray()) + ", ");
    System.out.print(c("UPWARD".toCharArray()) + ", ");
    System.out.print(c("EXAMINATION".toCharArray()) + ", ");
    System.out.print(c("AZBYCXDWEVFUGTHSIRJQKPLOMN".toCharArray()) + ", ");

    System.out.print(c("AAA".toCharArray()) + ", ");
    System.out.print(c("ACE".toCharArray()) + ", ");
    System.out.print(c("THE".toCharArray()) + ", ");
    System.out.print(c("BUMPY".toCharArray()) + ", ");
    System.out.print(c("BALDING".toCharArray()) + ", ");
    System.out.print(c("ABCDEFGHIJKLMNOPQRSTUVWXYZ".toCharArray()) + ", ");
  }
}

Sortie:

1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0

PowerShell v2 +, 83 octets

param($n)($a=-join(1..($n.Length-1)|%{+($n[$_-1]-lt$n[$_])}))-eq($a-replace'00|11')

Un peu d'une approche différente. Cela boucle à travers l'entrée $n, chaque itération voyant si le caractère précédent $n[$_-1]est -less than le caractère actuel $n[$_], puis transtypant le résultat de cet opérateur booléen en un int avec +. Ceux-ci sont -joinédités ensemble dans une chaîne, stockés dans $a. Nous vérifions ensuite si $aest -eqcompatible $aavec les sous-chaînes de 00ou 11supprimées.

Python 2.7, 84 octets

s=input()
b=s[0]<s[1]
o=1
for i in range(len(s)-1):o&=(s[i]<s[i+1])==b;b^=1
print o

Renvoie 1 pour cahoteux, 0 pour sinon

J'ai appris des trucs sympas avec bit & et ^.
Commence par booléen b définissant la première paire comme haut / bas, puis teste et retourne b pour chaque paire suivante.
o bascule sur faux si le test échoue et colle.
Nécessite des guillemets autour de l'entrée (+4 octets pour raw_input () si cela enfreint une règle)

Essaye-le

05AB1E , 9 octets

SÇ¥0›¥_O_

Explication

SÇ          # convert to list of ascii values
  ¥         # take delta's
   0›       # check if positive, giving a list of 1's and 0's
            # if they alternate, the word is bumpy
     ¥      # take delta's again, if we have any 0's in the list the word is not bumpy
      _     # logical negation, turning 0 into 1 and everything else to 0
       O    # sum, producing 0 for a bumpy word and 1 for a non-bumpy word
        _   # logical negation, inverting the previous 1 into 0 and vice versa

Essayez-le en ligne!

Python 2.7 (encore une fois, 84 83 octets)

def a(s):x=s[1:];return[cmp(s[0],x)]+a(x) if x else []
print len(set(a(input())))>1

Ou, 78 77 octets sans l'impression.

À propos, l'exemple Python 2.7 de 56 octets ci-dessus se casse, par exemple, "abbab"ou toute autre entrée avec des caractères répétés. Tant pis, je n'ai pas lu les instructions. Révision.

D'accord, jusqu'à 83. Le triplet est plus joli cependant.

CJam , 15 octets

l2ew::<2ew::^:*

Essayez-le en ligne! (En tant que suite de tests séparés par des sauts de ligne.)

Explication

l    e# Read input.
2ew  e# Get all (overlapping) pairs.
::<  e# Check whether each pair is strictly ascending (1) or not (0).
2ew  e# Get all (overlapping) pairs.
::^  e# Take the bitwise XOR of each pair, giving 1 if a rise and a fall alternate,
     e# and zero if there are two rises or two falls in succession.
:*   e# Product. Gives 1 only if the previous step yielded a list of 1s, meaning
     e# that any two consecutive rises/falls will turn this into a zero.

PHP, 80 octets

$s=$argv[1];for($c=$s[0];$n=$s[++$i];$c=$n,$d=$e)if($d===$e=$n>$c)break;echo!$n;

ou

for($c=$argv[1][0];$n=$argv[1][++$i];$c=$n,$d=$e)if($d===$e=$n>$c)break;echo!$n;

sortie vide pour faux, 1pour vrai

ou approche récursive de Hedi portée et un peu golfée pour 70 octets:

function f($s){return!$s[2]|$s[0]<$s[1]^$s[1]<$s[2]&&f(substr($s,1));}

En fait, cela devrait récurrence infiniment pour les mots cahoteux, mais ce n'est pas le cas!

Haskell, 30 37 octets

q f=tail>>=zipWith f;k=and.q(/=).q(>)

Usage:

Prelude> k <$> words "ABA ABB BAB BUMP BALD BALDY UPWARD EXAMINATION AZBYCXDWEVFUGTHSIRJQKPLOMN"
[True,True,True,True,True,True,True,True,True]

Prelude> k <$> words "AAA BBA ACE THE BUMPY BALDING ABCDEFGHIJKLMNOPQRSTUVWXYZ"
[False,False,False,False,False,False,False]

PHP 7, 137 118 octets

for($i=0;$i<strlen($argv[1])-2;$i++)if(((($s[$i]<=>$s[$i+1])<0)?1:0)==((($s[$i+1]<=>$s[$i+2])<0)?1:0)){echo"0";break;}

Sortie vide pour Bumpy, 0 pour Not Bumpy.

C'est ma première tentative de golf à code et je dois m'améliorer beaucoup, mais c'était une merveilleuse méthode pour apprendre de nouvelles choses pour moi. Je voulais également me mettre au défi dans cette tâche en utilisant le nouvel opérateur PHP 7 Spaceship qui semble très intéressant.

Quoi qu'il en soit, je ne suis pas satisfait, tout d'abord pour le fait que j'ai dû ajouter un supplément if(isset($s[$i+2]))pour vérifier si la variable existe parce que je n'ai pas trouvé d'autre solution au problème, mais c'est tout pour le moment. (Remarque: j'ai corrigé cela simplement en changeant strlen($s)-1en strlen($s)-2, je ne pouvais pas vraiment voir ça avant ...).

Code de test:

$as = array("ABA", "ABB", "BAB", "BUMP", "BALD", "BALDY", "UPWARD", 
            "EXAMINATION", "AZBYCXDWEVFUGTHSIRJQKPLOMN", "AAA", "BBA", 
            "ACE", "THE", "BUMPY", "BALDING", "ABCDEFGHIJKLMNOPQRSTUVWXYZ");

foreach ($as as $s) {
    for($i=0;$i<strlen($s)-2;$i++)if(((($s[$i]<=>$s[$i+1])<0)?1:0)==((($s[$i+1]<=>$s[$i+2])<0)?1:0)){echo"0";break;}
}

Testez en ligne

Javascript ES6, 100 octets

d="charCodeAt";a=b=>{f=r=0;for(i=1;i<b.length;i++){if(b[d](i)<=b[d](i-1)){f=1}else{r=1}}return f&&r}

Essayez-le ici:

d="charCodeAt";a=b=>{f=r=0;for(i=1;i<b.length;i++){if(b[d](i)<=b[d](i-1)){f=1}else{r=1}}return f&&r}
alert(a(prompt()));

Oh allez, deux personnes me l'ont déjà battu de 40 octets ... peu importe

Python 3, 148 139 127 octets

def _(w):*r,=map(lambda a,b:0>ord(a)-ord(b)and-1or 1,w,w[1:]);s=len(r)%2==0and r+[r[0]]or r;return sum(s)in(-1,1)and s==s[::-1]

code de test

positives = ('ABA', 'ABB', 'BAB', 'BUMP', 'BALD', 'BALDY', 'UPWARD', 'EXAMINATION', 'AZBYCXDWEVFUGTHSIRJQKPLOMN')
negatives = ('AAA', 'BBA', 'ACE', 'THE', 'BUMPY', 'BALDING', 'ABCDEFGHIJKLMNOPQRSTUVWXYZ')

for w in positives:
    print(_(w), w)
    assert _(w)

for w in negatives:
    print(_(w), w)
    assert not _(w)

C 65 57 60 octets

 r;f(char*s){for(r=0;*++s&&(r=~r&1<<(*s>*(s-1))););return r;}

est correct de

r;f(char*s){for(;*++s&&(r=~r&1<<(*s>*(s-1))););return r;}

qui fonctionne correctement avec toutes les données uniquement lors d'un appel de fonction unique (lorsque la variable globale rest initialisée à zéro).

Mais dans tous les cas, c'est plus court que la solution précédente (65 octets) en raison de l'utilisation de forau lieu de while. Mais le précédent (ce qui suit) est un peu plus facile à comprendre:

r;f(char*s){while(*++s)if(!(r=~r&1<<(*s>*(s-1))))break;return r;}

Ma solution est basée sur le bit &avec le code de direction précédent et actuel inversé, où le code de direction peut être 2( 1<<1) pour augmenter le code de caractère ( *s > *(s-1)) ou 1( 1<<0) sinon. Le résultat de cette opération est devenu 0 si nous utilisons le même code de direction que précédent et actuel, c'est-à-dire lorsque le mot n'est pas cahoteux.

MISE À JOUR:

Code de test:

#include <stdio.h>
#include <string.h>

r;f(char*s){for(;*++s&&(r=~r&1<<(*s>*(s-1))););return r;}

int main(void)
{
    char * Truthy[] = { "ABA", 
                        "ABB", 
                        "BAB",
                        "BUMP",
                        "BALD",
                        "BALDY",
                        "UPWARD",
                        "EXAMINATION",
                        "AZBYCXDWEVFUGTHSIRJQKPLOMN" };
    char * Falsey[] = { "AAA",
                        "BBA",
                        "ACE",
                        "THE",
                        "BUMPY",
                        "BALDING",
                        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"};
    int posTestNum = sizeof(Truthy) / sizeof(char *);
    int negTestNum = sizeof(Falsey) / sizeof(char *);
    int i;
    int rate = 0;
    int tests = 0;
    int res = 0;
    printf("Truthy (%d tests):\n", posTestNum);
    for (i = 0; i < posTestNum; i++)
    {
        tests++;
        printf("%s - %s\n", Truthy[i], f(Truthy[i]) ? (rate++, "OK") : "Fail");
        r = 0;
    }
    printf("\nFalsey (%d tests):\n", negTestNum);
    for (i = 0; i < negTestNum; i++)
    {
        tests++;
        printf("%s - %s\n", Falsey[i], f(Falsey[i]) ? "Fail" : (rate++, "OK"));
        r = 0;
    }
    printf("\n%d of %d tests passed\n", rate, tests);
    return 0;
}

PHP, 100 octets

for($s=$argv[1];$i<strlen($s)-1;$i++)$s[$i]=$s[$i+1]>$s[$i]?r:f;echo str_replace([rr,ff],'',$s)==$s;

Remplace chaque caractère de la chaîne (sauf le dernier évidemment) par un rpour augmenter ou un fpour tomber, puis vérifie si rrou ffse produisent dans la chaîne. Pour éviter que le dernier caractère restant interfère avec cela, l'entrée doit être entièrement en majuscules.

Je suis très insatisfait de la boucle, par exemple, j'ai le sentiment qu'il doit y avoir un moyen de combiner le $i++dans l'un des nombreux $is utilisés dans la boucle, mais je n'ai pas réussi à trouver cette façon. Peut-être que quelqu'un d'autre le voit.

(C'est aussi pourquoi j'ai posté mon code, bien qu'il soit 20 (!) Octets de plus que la belle solution de Titus.)

Java 8, 114 90 octets

(c,b)->{b=c[0]<c[1];for(int i=2;i<c.length;i++)if(c[i]>c[i-1]!=(b=!b))return 0;return 1;};

Programme de test non golfé

public static void main(String[] args) {
    BiFunction<char[], Boolean, Integer> func = (c, b) -> {
        b = c[0] < c[1];
        for (int i = 2; i < c.length; i++) {
            if (c[i] > c[i - 1] != (b = !b)) {
                return 0;
            }
        }
        return 1;
    };

    System.out.println(func.apply("ABCDEFG".toCharArray(), false));
    System.out.println(func.apply("AZBYCXDGEF".toCharArray(), false));
    System.out.println(func.apply("ZXZXZX".toCharArray(), false));
    System.out.println(func.apply("ZXCYZ".toCharArray(), false));
    System.out.println(func.apply("AAA".toCharArray(), false));
}