(ispirato a questa sfida su Puzzle - Gli SPOILER per quel puzzle sono qui sotto, quindi smetti di leggere qui se vuoi risolvere quel puzzle da solo!)

Se una lettera in una parola appare in ordine alfabetico più tardi rispetto alla lettera precedente nella parola, la chiamiamo un aumento tra le due lettere. Altrimenti, anche se è la stessa lettera , si chiama caduta .

Ad esempio, la parola ACEha due aumenti ( Ada Ce Ca E) e nessuna caduta, mentre THEha due cadute ( Tda He Ha E) e nessuna salita.

Chiamiamo una parola Bumpy se la sequenza di salite e discese si alterna. Ad esempio, BUMPva su ( Ba U), su ( Usu M), su ( Msu P). Si noti che la prima sequenza non deve necessariamente essere un aumento - BALDva caduta-salita-caduta ed è anche irregolare.

La sfida

Data una parola, emettere se è Bumpy o meno.

Ingresso

• Una parola (non necessariamente una parola del dizionario) costituita solo da lettere ASCII ( [A-Z]o [a-z]) alfabetiche , in qualsiasi formato adatto .
• La tua scelta se l'input è tutto maiuscolo o tutto minuscolo, ma deve essere coerente.
• La parola avrà una lunghezza di almeno 3 caratteri.

Produzione

Un valore di verità / falsità per indicare se la parola di input è Bumpy (verità) o no Bumpy (falsità).

Le regole

• È accettabile un programma completo o una funzione.
• Sono vietate le scappatoie standard .
• Si tratta di code-golf, quindi si applicano tutte le normali regole del golf e vince il codice più breve (in byte).

Esempi

Truthy:

ABA
ABB
BAB
BUMP
BALD
BALDY
UPWARD
EXAMINATION
AZBYCXDWEVFUGTHSIRJQKPLOMN

Falsey:

AAA
BBA
ACE
THE
BUMPY
BALDING
ABCDEFGHIJKLMNOPQRSTUVWXYZ

Classifiche

Ecco uno snippet di stack per generare sia una classifica regolare che una panoramica dei vincitori per lingua.

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, utilizzando il seguente modello Markdown:

# Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

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

Se si desidera includere più numeri nell'intestazione (ad es. Perché il punteggio è la somma di due file o si desidera elencare separatamente le penalità del flag dell'interprete), assicurarsi che il punteggio effettivo sia l' ultimo numero nell'intestazione:

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

Puoi anche rendere il nome della lingua un collegamento che verrà quindi visualizzato nello snippet della classifica:

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

d0>d

Spiegazione:

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

Questa è la mia prima voce MATL, quindi mi chiedo quanti miglioramenti ci possano essere da questa ingenua porta dal mio tentativo MATLAB / Octave (che sarebbe @(a)all(diff(diff(a)>0))). Si noti che allnon è necessario perché uno zero rende un array falso, quindi non è presente Anella porta MATL.

JavaScript (ES6), 75 69 63 46 43 byte

3 byte salvati grazie a Neil:

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

Distruzione del parametro stringa anziché s.slice(1).

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

Cosa è successo dalla soluzione precedente passo dopo 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 byte:

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

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

Tutte le lettere in una parola devono avere lo stesso caso.

LabVIEW, 36 byte equivalenti

Abbassato usando equivalenze logiche:

Ungolfed:

Prima convertiamo in minuscolo, quindi in array di byte. Taglia il primo elemento dell'array di byte poiché non ha precedenti. Quindi, per ogni elemento dell'array, controlla se è maggiore di quello precedente (il carattere U8 viene mappato su ASCII come previsto) e memorizza il risultato per la successiva iterazione, nonché in un array per la visualizzazione di irregolarità complessiva. Se il controllo booleano corrente e precedente sono uguali, terminiamo il loop e non è irregolare. Altrimenti, è accidentato!

Python, 56 byte

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

Tutti i casi di test sono su ideone

Comprime le triple di personaggi in se verifica che tutte queste triple abbiano coppie destra e sinistra con proprietà di salita / discesa diverse.
Funziona con tutte le lettere maiuscole o minuscole.

Rubino, 57 48 byte

Si aspetta che l'input sia tutto maiuscolo.

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

Guardalo su repl.it: https://repl.it/D7SB

Spiegazione

L'espressione regolare /.(?=(.)(.))/corrisponde a ciascun personaggio seguito da altri due caratteri. (?=...)è uno sguardo positivo, il che significa che abbiniamo i due personaggi successivi ma non li "consumiamo" come parte della partita. All'interno delle parentesi graffe, $&c'è il testo abbinato - il primo carattere dei tre - $1e $2sono i personaggi catturati all'interno del lookahead. In altre parole, se la stringa è "BUMPY", prima corrisponderà "B"(e la inserirà $&) e catturerà "U"e "M"(e inserirà $1e $2). Il prossimo corrisponderà "U"e la cattura "M"e "P", e così via.

All'interno del blocco controlliamo se la prima coppia di caratteri ( $&e $1) è un aumento e la seconda ( $1e $2) è una caduta o viceversa, proprio come la maggior parte delle altre risposte. Questa ^espressione restituisce trueo false, che viene convertito in una stringa e inserito al posto della corrispondenza. Di conseguenza, il nostro esempio "BUMPY"diventa questo:

"truetruefalsePY"

Poiché sappiamo che l'input è tutto in maiuscolo, sappiamo che "f"avverrà solo come parte di "false"e !result[?f]ci dà la nostra risposta.

C #, 64 63 55 byte

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

-8 byte dai suggerimenti di Scepheo

Questa è una porta della soluzione di Hedi a C #. Ho anche trovato una soluzione ricorsiva, ma la ricorsione non era altrettanto buona. La mia soluzione originale è di seguito.

My Original C #, 96 94 91 byte

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 byte usando 1>0invece di true.

-3 byte dai suggerimenti di Scepheo per la soluzione di porta sopra

Si chiama verificando ricorsivamente che l'alzata / la caduta si alternano ogni volta.

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 byte

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

Gelatina , 6 byte

OI>0IẠ

Basato sulla risposta di @sanchises .

Provalo online! o Verifica tutto.

Spiegazione

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 byte

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

.mapnon è sicuramente la soluzione migliore .

Python 2, 88 byte

Soluzione semplice.

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

Provalo online

Se le stesse lettere di fila non fossero né un aumento né una caduta, la soluzione sarebbe 79 byte:

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

Perl, 34 byte

Include +3 per -p(il codice contiene 'quindi -enon può essere utilizzato)

Fornisci input in maiuscolo su STDIN:

bump.pl <<< AAA

bump.pl

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

Python, 51 byte

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

Accetta input come g('B','U','M','P')e output 1o 0.

Usa l'argomento disimballaggio per prendere le prime tre lettere e verificare se le prime due si confrontano diversamente dalle seconde due. Quindi, ricorre sul resto, usando la moltiplicazione per and.

Gelatina , 6 5 byte

-1 byte grazie a @Dennis (utilizzare una riduzione cumulativa)

<2\IẠ

Tutti i casi di test sono su TryItOnline

Come?

<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

Funziona con tutte le lettere maiuscole o minuscole.

Japt, 8 byte

Uä> ä- e

Provalo online!

Come funziona

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 byte

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 byte Soluzione:

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

Provalo online

Utilizzando una matrice di caratteri è stato salvato un byte poiché lo spazio può essere omesso dopo le parentesi. f(string x)vsf(char[]x)

Sono 101 byte se posso restituire un int 1/0 invece di 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 byte

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

Ho il sospetto che potrei ridurlo un po 'se riuscissi a liberarmi del costrutto "where", ma probabilmente sono bloccato con zipWith.

Funziona creando un elenco degli aumenti (Vero) e delle cadute (Falso), quindi facendo un elenco di se le voci adiacenti in questo elenco sono diverse

Questo è il mio primo tentativo in uno di questi, quindi passerò attraverso il mio processo di pensiero nel caso in cui mi sia orribilmente sbagliato da qualche parte.

Versione Ungolfed (168 byte)

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

Abbreviare i nomi, rimuovere le informazioni sul tipo (100 byte)

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

Sposta h nella funzione principale poiché viene utilizzata una sola volta (86 byte)

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

Comprendi che areBumps e riseFall sono abbastanza simili all'astratto (73 byte)

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

Nota che (coda y) è più corta di ya @ (y: ys) (70 byte)

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

Riordinare; rimuovere gli spazi non necessari (52 byte)

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

Java 7, 157 153 150 125 117 byte

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

Casi non testati e test:

Provalo qui.

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

Produzione:

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

PowerShell v2 +, 83 byte

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

Un approccio un po 'diverso. Questo scorre attraverso l'input $n, ogni iterazione vede se il personaggio precedente $n[$_-1]è -lessenzialmente til personaggio attuale $n[$_], quindi lancia il risultato di quell'operatore booleano in un int con +. Quelli sono -joinmessi insieme in una stringa, memorizzati in $a. Abbiamo quindi verificare se $aè -eqUAL per $aeventuali sottostringhe di 00o 11rimossi.

Python 2.7, 84 byte

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

Restituisce 1 per irregolare, 0 per diversamente

Ho imparato alcune cose interessanti con bitwise & e ^.
Inizia con booleano b definendo la prima coppia come su / giù, quindi verifica e capovolge b per ciascuna coppia successiva.
o passa a falso se il test fallisce e si blocca.
Richiede virgolette attorno all'input (+4 byte per raw_input () se questo infrange alcune regole)

Provalo

05AB1E , 9 byte

SÇ¥0›¥_O_

Spiegazione

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

Provalo online!

Python 2.7 (di nuovo, 84 83 byte)

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

Oppure, 78 77 byte senza la stampa.

A proposito, l'esempio di Python 2.7 sopra 56 byte si interrompe, ad esempio, "abbab"o qualsiasi altro input con caratteri ripetuti. Non importa, non ho letto le istruzioni. Revisione.

Va bene, fino all'83. Quello triplo è comunque più bello.

CJam , 15 byte

l2ew::<2ew::^:*

Provalo online! (Come una suite di test separata da avanzamento riga.)

Spiegazione

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 byte

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

o

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

output vuoto per false, 1per true

o l' approccio ricorsivo di Hedi portato e un po 'giocato a golf per 70 byte:

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

In realtà, questo dovrebbe ricorrere all'infinito per parole sconnesse, ma non lo fa!

Haskell, 30 37 byte

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 byte

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

Output vuoto per Bumpy, 0per Not Bumpy.

Questo è il mio primo tentativo di giocare a golf con il codice e devo migliorare molto, ma è stato un metodo meraviglioso per imparare cose nuove per me. Volevo anche mettermi alla prova su questo compito utilizzando il nuovo operatore spaziale PHP 7 che sembra molto interessante.

Comunque non ne sono soddisfatto, prima di tutto per il fatto che ho dovuto aggiungere un extra if(isset($s[$i+2]))per verificare se la variabile esiste perché non ho trovato un'altra soluzione alternativa al problema, ma questo è tutto per ora. (Nota: ho risolto semplicemente cambiando strlen($s)-1in strlen($s)-2, non riuscivo a vederlo prima ...).

Codice di prova:

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

Test online

Javascript ES6, 100 byte

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}

Provalo qui:

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 andiamo, due persone mi hanno già battuto per 40 byte ... qualunque cosa

Python 3, 148 139 127 byte

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]

codice di prova

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 byte

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

è una correzione di

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

che funziona correttamente con qualsiasi dato solo alla chiamata di una singola funzione (quando la variabile globale rè inizializzata su zero).

Ma in ogni caso questo è più breve della soluzione precedente (65 byte) a causa dell'uso di forinvece di while. Ma precedente (il seguente) è un po 'più facile da capire:

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

La mia soluzione si basa su bit per volta &con il codice di direzione precedente e corrente invertito, dove il codice di direzione può essere 2( 1<<1) per aumentare il codice carattere ( *s > *(s-1)) o 1( 1<<0) in caso contrario. Il risultato di questa operazione diventa 0 se utilizziamo lo stesso codice di direzione come precedente e corrente, ovvero quando la parola non è irregolare.

AGGIORNARE:

Codice per il 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 byte

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;

Sostituisce ogni carattere della stringa (tranne l'ultimo ovviamente) con un raumento o una fcaduta e quindi controlla se rro si ffverificano nella stringa. Per evitare che l'ultimo carattere rimanente interferisca con quello, l'input deve essere tutto in maiuscolo.

Sono molto insoddisfatto del loop, ad esempio ho la sensazione che ci debba essere un modo per combinare $i++uno dei vari $is usati nel loop, ma non sono riuscito a trovarlo. Forse qualcun altro lo vede.

(Questo è anche il motivo per cui ho pubblicato il mio codice, nonostante sia 20 (!) Byte più lungo della bella soluzione di Titus.)

Java 8, 114 90 byte

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

Programma di test non golfato

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