(inspirado nesse desafio de Puzzling - SPOILERS para esse quebra-cabeça está abaixo, então pare de ler aqui se você quiser resolver esse quebra-cabeça sozinho!)

Se uma letra em uma palavra ocorre alfabeticamente depois da letra anterior, chamamos isso de aumento entre as duas letras. Caso contrário, inclusive se for a mesma letra , será chamada de queda .

Por exemplo, a palavra ACEtem duas subidas ( Apara Ce Cpara E) e sem quedas, enquanto que THEtem duas quedas ( Tpara He Hpara E) e sem subidas.

Chamamos uma palavra de instável se a sequência de subidas e descidas se alterna. Por exemplo, BUMPvai subir ( Bpara U), cair ( Upara M), subir ( Mpara P). Observe que a primeira sequência não precisa ser uma subida - BALDvai subindo subindo e descendo e também é instável.

O desafio

Dada uma palavra, a saída seja Bumpy ou não.

Entrada

• Uma palavra (não necessariamente uma palavra do dicionário) que consiste apenas no alfabeto ASCII ( [A-Z]ou [a-z]), em qualquer formato adequado .
• Sua escolha se a entrada for toda maiúscula ou minúscula, mas deve ser consistente.
• A palavra terá pelo menos três caracteres.

Saída

Um valor truthy / falsey para saber se a palavra de entrada é Acidentada (truthy) ou não Acidentada (falsey).

As regras

• Um programa completo ou uma função são aceitáveis.
• As brechas padrão são proibidas.
• Isso é código-golfe, portanto todas as regras usuais de golfe se aplicam e o código mais curto (em bytes) vence.

Exemplos

Verdade:

ABA
ABB
BAB
BUMP
BALD
BALDY
UPWARD
EXAMINATION
AZBYCXDWEVFUGTHSIRJQKPLOMN

Falsey:

AAA
BBA
ACE
THE
BUMPY
BALDING
ABCDEFGHIJKLMNOPQRSTUVWXYZ

Classificação

Aqui está um snippet de pilha para gerar uma classificação regular e uma visão geral dos vencedores por idioma.

Para garantir que sua resposta seja exibida, inicie-a com um título, usando o seguinte modelo de remarcação:

# Language Name, N bytes

onde Nestá o tamanho do seu envio. Se você melhorar sua pontuação, poderá manter as pontuações antigas no título, identificando-as. Por exemplo:

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

Se você quiser incluir vários números no cabeçalho (por exemplo, porque sua pontuação é a soma de dois arquivos ou você deseja listar as penalidades do sinalizador de intérpretes separadamente), verifique se a pontuação real é o último número no cabeçalho:

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

Você também pode transformar o nome do idioma em um link que será exibido no snippet do placar de líderes:

# [><>](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 bytes

d0>d

Explicação:

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

Esta é a minha primeira entrada no MATL, então, pergunto-me quanta melhoria pode haver dessa porta ingênua da minha tentativa do MATLAB / Octave (o que seria @(a)all(diff(diff(a)>0))). Observe que isso allnão é necessário porque qualquer zero torna uma matriz falsa; portanto, não há Ana porta MATL.

JavaScript (ES6), 75 69 63 46 43 bytes

Economizou 3 bytes graças a Neil:

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

Destruindo o parâmetro string em vez de s.slice(1).

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

O que aconteceu com a solução anterior passo a passo:

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 bytes:

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 bytes:

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

Todas as letras de uma palavra devem ter o mesmo caso.

LabVIEW, 36 bytes equivalentes

Golfe usando equivalências lógicas:

Ungolfed:

Primeiro, convertemos para minúsculas e depois para a matriz de bytes. Apare o primeiro elemento da matriz de bytes, pois ela não tem precedentes. Em seguida, para cada elemento da matriz, verifique se é maior que o anterior (o caractere U8 é mapeado para ASCII conforme o esperado) e armazene o resultado para a próxima iteração, bem como em uma matriz para visualizar o bumpiness geral. Se a verificação booleana atual e anterior for igual, encerramos o loop e não é acidentado. Senão, é acidentado!

Python, 56 bytes

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

Todos os casos de teste estão em ideone

Percorre triplos caracteres em s e testa se todos esses triplos têm pares esquerdo e direito com diferentes propriedades de subida / descida.
Funciona para todas as maiúsculas ou minúsculas.

Ruby, 57 48 bytes

Espera que a entrada seja todas maiúscula.

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

Veja em repl.it: https://repl.it/D7SB

Explicação

A expressão regular /.(?=(.)(.))/corresponde a cada caractere que é seguido por mais dois caracteres. (?=...)é uma visão positiva, o que significa que combinamos os dois caracteres subsequentes, mas não os "consumimos" como parte da correspondência. Dentro das chaves, $&é o texto-o primeiro caractere combinado dos três-e $1e $2são os personagens capturados dentro da visão antecipada. Em outras palavras, se a string for "BUMPY", ela corresponderá primeiro "B"(e a colocará $&) e capturará "U"e "M"(e as colocará em $1e $2). Em seguida, ele irá corresponder "U"e captura "M"e "P", e assim por diante.

Dentro do bloco, verificamos se o primeiro par de caracteres ( $&e $1) é um aumento e o segundo ( $1e $2) é uma queda ou vice-versa, bem como a maioria das outras respostas. Essa ^expressão retorna trueor false, que é convertida em uma sequência e inserida no lugar da correspondência. Como resultado, nosso exemplo "BUMPY"se torna o seguinte:

"truetruefalsePY"

Como sabemos que a entrada está toda em maiúscula, sabemos "f"que apenas ocorrerá como parte "false"e !result[?f]nos dará nossa resposta.

C #, 64 63 55 bytes

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

-8 bytes de sugestões de Scepheo

Esta é uma porta da solução da Hedi para C #. Eu também vim com uma solução recursiva, mas a recursão não foi tão boa. Minha solução original está abaixo.

Meu C # original, 96 94 91 bytes

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 bytes usando em 1>0vez de true.

-3 bytes das sugestões do Scepheo para a solução de porta acima

Chama a si próprio verificando recursivamente que a subida / descida alterna cada vez.

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 bytes

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

Gelatina , 6 bytes

OI>0IẠ

Com base na resposta de @sanchises .

Experimente online! ou Verifique tudo.

Explicação

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 bytes

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

.mapé não definitivamente a melhor solução .

Python 2, 88 bytes

Solução simples.

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

Experimente online

Se as mesmas letras seguidas não aumentassem nem diminuíssem, a solução seria 79 bytes:

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

Perl, 34 bytes

Inclui +3 para -p(o código contém, 'portanto, -enão pode ser usado)

Dê entrada em maiúsculas no STDIN:

bump.pl <<< AAA

bump.pl

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

Python, 51 bytes

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

Toma entradas g('B','U','M','P')e saídas como 1ou 0.

Usa o argumento de descompactação para pegar as três primeiras letras e verificar se as duas primeiras se comparam de maneira diferente das duas primeiras. Em seguida, repete-se no restante, usando multiplicação para and.

Gelatina , 6 5 bytes

-1 byte graças a @Dennis (use uma redução cumulativa)

<2\IẠ

Todos os casos de teste estão em TryItOnline

Quão?

<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

Funciona para todas as maiúsculas ou minúsculas.

Japonês, 8 bytes

Uä> ä- e

Teste online!

Como funciona

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 bytes

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 bytes Solução:

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

Experimente online

O uso de uma matriz de caracteres salvou um byte, pois o espaço pode ser omitido após os colchetes. f(string x)vsf(char[]x)

São 101 bytes se eu posso retornar um int 1/0 em vez 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 bytes

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

Eu suspeito que eu poderia diminuir um pouco se conseguisse me livrar da construção "where", mas provavelmente estou presa ao zipWith.

Isso funciona fazendo uma lista dos aumentos (True) e das quedas (False) e, em seguida, fazendo uma lista de se as entradas ajacent nesta lista são diferentes

Esta é a minha primeira tentativa de uma delas, então vou passar pelo meu processo de pensamento, caso eu tenha cometido um erro horrível em algum lugar.

Versão Ungolfed (168 bytes)

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

Encurte nomes, remova informações de tipo (100 bytes)

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

Mova h para a função principal, pois ela é usada apenas uma vez (86 bytes)

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

Perceba que areBumps e riseFall são semelhantes o suficiente para abstrair (73 bytes)

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

Observe que (cauda y) é menor que ya @ (y: ys) (70 bytes)

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

Arrumar; remover espaços desnecessários (52 bytes)

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

Java 7, 157 153 150 150 125 117 bytes

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

Casos não testados e de teste:

Experimente aqui.

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()) + ", ");
  }
}

Saída:

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

PowerShell v2 +, 83 bytes

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

Um pouco de uma abordagem diferente. Isso percorre a entrada $n, cada iteração verificando se o caractere anterior $n[$_-1]é -less than o caractere atual e $n[$_], em seguida, convertendo o resultado desse operador booleano para um int com +. Esses são -joineditados juntos em uma string, armazenados em $a. Em seguida, verificar se $aé -equal para $acom todos os substrings de 00ou 11removidos.

Python 2.7, 84 bytes

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

Retorna 1 para acidentado, 0 para caso contrário

Aprendeu algumas coisas legais com bit a bit & e ^.
Começa com booleano b definindo o primeiro par como cima / baixo, depois testa e vira b para cada par seguinte.
o vira para falso se o teste falhar e persistir.
Requer aspas ao redor da entrada (+4 bytes para raw_input () se isso quebra alguma regra)

Teste-o

05AB1E , 9 bytes

SÇ¥0›¥_O_

Explicação

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

Experimente online!

Python 2.7 (novamente, 84 83 bytes)

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 bytes sem a impressão.

A propósito, o exemplo acima de 56 bytes do Python 2.7 interrompe, por exemplo, "abbab"ou qualquer outra entrada com caracteres repetidos. Não importa, não leu instruções. Revisando.

Ok, até 83. O triplo é melhor.

CJam , 15 bytes

l2ew::<2ew::^:*

Experimente online! (Como um conjunto de testes separado por avanço de linha.)

Explicação

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 bytes

$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;

saída vazia para falso, 1para verdadeiro

ou a abordagem recursiva de Hedi e portada e um pouco jogada por 70 bytes:

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

Na verdade, isso deve recair infinitamente por palavras esburacadas, mas não!

Haskell, 30 37 bytes

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

Uso:

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 bytes

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

Saída vazia para Bumpy, 0para Not Bumpy.

Esta é minha primeira tentativa no código de golfe e preciso melhorar bastante, mas foi um método maravilhoso para aprender coisas novas para mim. Eu também queria me desafiar nessa tarefa usando o novo Operador de espaçonave PHP 7, que parece muito interessante.

De qualquer forma, não estou satisfeito com isso, antes de tudo, pelo fato de precisar adicionar um extra if(isset($s[$i+2]))para verificar se a variável existe, porque não encontrei outra solução alternativa para o problema, mas é isso por enquanto. (Nota: eu consertei isso simplesmente mudando strlen($s)-1para strlen($s)-2, eu realmente não conseguia ver isso antes ...).

Código de teste:

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

Teste on-line

Javascript ES6, 100 bytes

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}

Experimente aqui:

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, vamos lá, duas pessoas já me venceram por 40 bytes ...

Python 3, 148 139 127 bytes

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]

código de teste

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 bytes

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

é conserto de

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

que funciona corretamente com todos os dados apenas em uma única chamada de função (quando a variável global ré inicializada como zero).

Mas, em qualquer caso, isso é mais curto que a solução anterior (65 bytes) devido ao uso de em forvez de while. Mas anterior (a seguir) é um pouco mais fácil de entender:

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

Minha solução é baseada em bit a bit &com o código de direção anterior e atual invertido, onde o código de direção pode ser 2( 1<<1) para aumentar o código de caractere ( *s > *(s-1)) ou 1( 1<<0) caso contrário. O resultado desta operação tornou-se 0 se usarmos o mesmo código de direção que o anterior e o atual, ou seja, quando a palavra não for acidentada.

ATUALIZAR:

Código para teste:

#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 bytes

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;

Substitui todos os caracteres da cadeia de caracteres (exceto o último, obviamente) por um rpara aumento ou um fpara queda e, em seguida, verifica se ocorre rrou ffocorre na cadeia. Para evitar que o último caractere restante interfira com isso, a entrada deve estar em letras maiúsculas.

Estou muito insatisfeito com o loop, por exemplo, tenho a sensação de que deve haver uma maneira de combinar o $i++em um dos vários $is usados ​​no loop, mas não consegui encontrar esse caminho. Talvez alguém mais veja.

(Foi também por isso que publiquei meu código, apesar de ter 20 (!) Bytes a mais que a boa solução de Titus.)

Java 8, 114 90 bytes

(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;};

Programa de teste ungolfed

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