波状数の間の桁代替番号でアップ及びダウン 2 <3ので、461902又は708143、あるいは1010101はなく、123以下の数など。

プログラムまたは機能番号がある場合truthy値を返す書き込み波状、さもなければfalsy値。最短のコードが優先されます。

注：1桁の数字は有効な入力ですが、udulantとは見なされないisUndulantため、n <10に対してfalseを返します。

J、45

*./(n>9),(}:(=-)}.)(}:*@-}.)n#:~10$~>.10^.n=.

使用例：

   *./(n>9),(}:(=-)}.)(}:*@-}.)n#:~10$~>.10^.n=. 461902
1
   *./(n>9),(}:(=-)}.)(}:*@-}.)n#:~10$~>.10^.n=. 708143
1
   *./(n>9),(}:(=-)}.)(}:*@-}.)n#:~10$~>.10^.n=. 1010101
1
   *./(n>9),(}:(=-)}.)(}:*@-}.)n#:~10$~>.10^.n=. 123
0
   *./(n>9),(}:(=-)}.)(}:*@-}.)n#:~10$~>.10^.n=. 5
0

Insert /を回してより多くの作業を行うためのより良い方法があると確信していますが、私は何ヶ月もJレスでしたので、それに戻る必要があります。

ルビー、72 70文字

Q=10;k=->n,v{(n%Q-n/Q%Q)*v<0?k[n/Q,-v]:n<Q};u=->n{n>9&&k[n,-1]|k[n,1]}

使用法とテストケース：

p u[10101]   # <= true
p u[708143]  # <= true
p u[2421]    # <= false
p u[1231]    # <= false
p u[873]     # <= false

1桁の場合はfalseになります。

p u[5]       # <= false

連続する同一の数字もfalseを返します。

p u[66]      # <= false
p u[1221]    # <= false

J、30バイト

*/0<(#,]*{.*1 _1$~#)2-/\a.i.":

他のJの回答とは異なるアプローチ。

   * / 0 <（＃、] * {。* 1 _1 $〜＃）2-/ \ ai "：461902
1
   * / 0 <（＃、] * {。* 1 _1 $〜＃）2-/ \ ai "：708143
1
   * / 0 <（＃、] * {。* 1 _1 $〜＃）2-/ \ ai "：1010101
1
   * / 0 <（＃、] * {。* 1 _1 $〜＃）2-/ \ ai "：123
0
   * / 0 <（＃、] * {。* 1 _1 $〜＃）（} .-} :) ai "：5
0

5が波状と見なされた場合、3文字短くなります。

（pdf）eTeX、129文字

\def\a#1#2{\if#2?\ifx\r\s\def\s{1}\else
True\end\fi\fi\edef\t{\pdfstrcmp{#2}{#1}}\ifx\s\t
False\end\fi\let\s\t\a#2}\expandafter\a

でコンパイルするとpdfetex filename.tex 1324?、pdf出力が得られます。TeXは主に組版言語であり、代わりにstdoutに出力すると、さらに20文字ほどかかります。また、1桁の数字（trueではなくfalse）の奇妙な要件により、26文字かかります。

Haskell、88 77 73 65文字

z=tail>>=zipWith compare
q[]=0>1
q s=all(/=EQ)$s++z s
u=q.z.show

これには、よく使用される言語プラグマ（または-Xフラグ）が必要ですNoMonomorphismRestriction。認めない場合は、4文字を追加して定義する必要zがあります。

z s=zipWith compare s$tail s

セージ、83 76バイト

f=lambda x:uniq(cmp(*`x`[i-2:i][::(-1)^i])for i in[2..len(`x`)])in[[1],[-1]]

JBernardoのcmp（* [..]）を使用するというアイデアを得ました。Sageではuniq(...)、はのエイリアスですlist(set(...))。

編集：x <10の場合uniq(cmp(...)) == []、オンではないことに注意してください[[1],[-1]]。xが整数ではなく文字列として入力された場合、さらに4文字を取り出すことができます！

Python：101100文字

縮小前：

undulate = (lambda n: n > 9
            and all(cmp(*digits) == (i % 2) * 2 - 1
                    for i, digits
                    in enumerate(zip(min(`n`,`n`[1:]), 
                                     max(`n`,`n`[1:])))))

縮小後：

a=lambda b:b>9and all(cmp(*c)==d%2*2-1 for d,c in enumerate(zip(min(`b`,`b`[1:]),max(`b`,`b`[1:]))))

Python、134 129文字

def f(x):d=[cmp(*i)for i in zip(`x`,`x`[1:])]if x>9 else[0];n=d[0]>0;return all(i<0 for i in d[n::2])&all(i>0 for i in d[n<1::2])

ゴルフをしていない：

def f(x):
    if x>9:
        d = [cmp(*i)for i in zip(`x`,`x`[1:])] #difference of x[i] and x[i+1]
    else:
        d = [0]       #trick to return False if x<10 using less chars
    n = d[0]>0        #First digit is -1 or 1?
    neg = d[n::2]     #negative numbers if x is Undulant
    pos = d[not n::2] #positive numbers if x is Undulant

    #check if all negs are -1 and all pos are 1 and return value
    return all(i<0 for i in neg) and all(i>0 for i in pos)

JavaScript、88文字

function _(i){i+='';c=i[0];f=i[a=x=1];for(g=f<c;d=i[x++];c=d)g^=a&=g?d<c:d>c;return!f^a}

本質的に、数値を文字列に変換し、隣接する文字を比較して、それぞれの期待を反転させます。

K、41バイト

{(x>9)&~max(=). 1_'-':'1_'(<':;>':)@\:$x}

例えば

{(x>9)&~max(=). 1_'-':'1_'(<':;>':)@\:$x}1212130659
1b

CoffeeScript、 98 67 53バイト

(n)->0!in((n[i]>=c^(n[0]<n[1])+i)%2for c,i in n[1..])

テスト：

[
    '01010101' # true
    '12345'    # false
    '1010101'  # true
    '887685'   # false
    '9120734'  # true
    '090909'   # true
]

非圧縮：

undulant = (n) ->
    direction = n[0] < n[1]
    return n.split('').every (cur, i) ->
        prev = arr[i-1] or 10 * direction
        +(prev >= cur) is (direction+i)%2

J、44 39 36 31バイト

*/2(0<#@],0>*/\)*2-/\".;' ',.":

前と同じように使用します。

前回の編集で、0チェックによる不等式が完全に不要になったことに気付いていませんでした。:-)

前の回答（+説明）：

(0=+/2=/\u)*(1<#u)**/2~:/\2<:/\u=.".;' ',.":

使用法：

    (0=+/2=/\u)*(1<#u)**/2~:/\2<:/\u=.".;' ',.":461902
1

答えには4つの部分があります。

1. u=.".;' ',.": これは数字を文字列として読み取り、":スペースを前に付けた文字のリストに分割し' ',.、ステッチし;て戻し、数字に変換して".保存しますu=.これは基本的に461902を4 6 1 9 0 2 に変換しますJで処理する

2. */2~:/\2<:/\ これは、uに格納されている値に対して動作します。文字の各ペアを取得し、左の文字が右の文字以下であるかどうかをチェックして、2<:/\4 6 1 9 0 2が1 0 1 0 1になるようにします。2~:/\したがって、1 0 1 0 1は1 1 1 1になります。最後に、それらをすべて乗算して0または1を取得します*/。この時点で、2つの事柄がなかった場合、答えを返すことができます。質問には0が必要です。等しい数は「より小さい」と同じように扱われるため、461900は0ではなく1を返します。行きます...

3. (1<#u) これは、uに格納されているアイテムの数が#u1より大きいかどうかをチェックし、1桁の数字の場合はfalseを返します。

4. (0=+/2=/\u) これは、uに格納されている数値の各ペアを取得し、等価性をチェックし2=/\uます。次に、回答を合計し、0があるかどうかを確認します。

次に、パート2、3、および4の結果は、数が質問で指定された要件を満たしている場合に（できれば）1を生成するために乗算されます。

Haskell、82バイト

c=cycle[(<),(>)]
l!n=n>9&&and(zipWith3($)l(show n)$tail$show n)
u n=c!n||((>):c)!n

オンラインでお試しください！

Python、119108バイト

def u(x):l=[cmp(i,j)for i,j in zip(`x`,`x`[1:])];print x>9and all([i*j<0 for i,j in zip(l,l[1:])])and l!=[0]

Python、155文字

g=lambda a,b:all(x>y for x,y in zip(a,b))
u=lambda D:g(D[::2],D[1::2])&g(D[2::2],D[1::2])
def U(n):D=map(int,str(n));return(n>9)&(u(D)|u([-d for d in D]))

C ++、94文字

bool u(int N){int K,P,Q,U=1,D=1;while(N>9)P=N%10,Q=(N/=10)%10,K=D,D=U&Q<P,U=K&Q>P;return U^D;}

再帰ではなくforループを使用する私のErlangオーナと同じメソッド。

パイソン105 101 100文字

c=lambda r,t:len(r)<2 or(cmp(*r[:2])==t and c(r[1:],-t))
u=lambda x:x>9and c(`x`,cmp(*`x`[:2])or 1)

再帰的なソリューション。c(r,t)の最初の文字が2番目の文字よりr少ない(t==-1)か大きい(t==1)かをチェックし、短縮文字列に対して反対のチェックを呼び出します。

Perl / re、139バイト

正規表現ですべてを行うことは、一種の悪い考えです。

/^(?:(.)(?{local$a=$1}))?(?:(?>((.)(?(?{$a lt$3})(?{local$a=$3})|(?!)))((.)(?(?{$a gt$5})(?{local$a=$5})|(?!))))*(?2)?)(?(?{pos>1})|(?!))$/

私はPerl 5.12を使用していますが、これはPerl 5.10でも動作すると思います。5.8がリリースされたことはかなり確かです。

for（qw（461902 708143 1010101 123 5））{
    print "$ _ is"。（/ クレイジー正規表現はここに行く /？ ''： 'not'）。"ゆるい\ n";
}

461902は波状です
708143は波状です
1010101は波状です
123は波乱ではありません
5はゆるやかではありません

GolfScript、48バイト

[`..,(<\1>]zip{..$=\-1%.$=-}%(\{.@*0<*}/abs

GolfScriptを初めて使用してJに勝つことを望んでいます。うまくいきませんでした。

JavaScript、66 65 62 60バイト

入力を文字列としてtrue受け取り、波状の数字の場合は返します。1桁の数字のfalse場合は空の文字列（falsey）を返します。

([s,...a])=>a+a&&a.every(x=>eval(s+"<>"[++y%2]+x,s=x),y=s<a)

それを試してみてください

以下のスニペットを実行して0-9、25個の乱数をテストします<10,000,000。

f=
([s,...a])=>a+a&&a.every(x=>eval(s+"<>"[++y%2]+x,s=x),y=s<a)
tests=new Set([...Array(10).keys()])
while(tests.add(Math.random()*1e7|0).size<35);
o.innerText=[...tests].map(x=>(x=x+``).padStart(7)+` = `+JSON.stringify(f(x))).join`\n`

<pre id=o></pre>

説明

この中にいくつかの楽しい小さなトリックがあるので、私からのJSソリューションへのまれな説明が必要だと思います。

()=>

単純に、呼び出されたときに整数文字列を引数として取る匿名関数から始めます。

[s,...a]

その引数は、すぐに2つのパラメータに非構造されています。s文字列の最初の文字であることとa、残りの文字を含む配列であること（例えば"461902"なりs="4"とa=["6","1","9","0","2"]）。

a+a&&

最初に、aそれ自体と連結し、両方の出現を文字列にキャストします。入力が1桁の数字の場合、a空になるため、空の文字列になります。空の文字列と空の文字列はまだ空の文字列であり、JSでは偽であるため、論理ANDで処理を停止し、空の文字列を出力します。それ以外の場合a+aはすべて真実であるため、関数の次の部分に進みます。

a.every(x=>)

関数を通過したときに、すべての要素xがa返されるかどうかを確認しますtrue。

y=s<a

これにより、最初の比較結果（<または>）が決まり、そこから交互に切り替えます。文字列があれば我々はチェックs少ない配列よりもaあれば、そうプロセス内の文字列にキャストされます、s以下の最初の文字よりもa、yだろうtrueか、falseそうでない場合。

s+"<>"[++y%2]+x

s最初とx最後に現在の値を持つ文字列を作成します。その間、"<>"インクリメントして文字列にインデックスを付け、yその初期ブール値を整数にキャストし、2を法として、0またはを与え1ます。

eval()

その文字列を評価します。

s=x

最後に、eval無視する2番目の引数をに渡し、それを使用しての値を次の反復のs現在の値に設定しxます。

PowerShell、88

ナイーブでつまらない。後でゴルフします。

filter u{-join([char[]]"$_"|%{if($n){[Math]::Sign($n-$_)+1}$n=$_})-notmatch'1|22|00|^$'}

私のテストケース。

JavaScript、112

function(n,d,l,c,f){while(l=n%10,n=n/10|0)d=n%10,c?c>0?d>=l?(f=0):(c=-c):d<=l?(f=0):(c=-c):(c=d-l,f=1);return f}

引数を1つ渡すだけで済みます。おそらくforループでこれをさらにゴルフできます。

アーラン、137の 123 118文字

u(N)->Q=N div 10,u(Q,N rem 10,Q>0,Q>0). u(0,_,D,U)->D or U;u(N,P,D,U)->Q=N rem 10,u(N div 10,Q,U and(Q<P),D and(Q>P)).

CJam、30バイト

CJamはこのチャレンジよりも新しいので、これは緑色のチェックマークと競合しませんが、とにかく勝者ではありません（実際、これはかなりゴルフできると確信していますが）。

l"_1=\+{_@-\}*;]"_8'*t+~{W>},!

ここでテストしてください。

使い方

まず、重複するコードで5バイトを節約するために、文字列操作（evalが後に続く）を実行しています。

"..."_8'*t+~
"..."        "Push this string.":
     _       "Duplicate.";
      8'*t   "Replace the 8th character (the -) with *.";
          +~ "Concatenate the strings and evaluate.";

したがって、実際には私のコードは

l_1=\+{_@-\}*;]_1=\+{_@*\}*;]{W>},!

最初に、1桁という奇妙な特殊なケースに対処する方法を示します。indexの数字をコピーし、数字の1前に追加します。3つのケースを区別する必要があります。

• 最初の2桁は異なります。 12...、212...するため、開始は波状であり、数値全体が波状であるかどうかには影響しません。
• 最初の2桁は同じです。 11...になります111...。スタートは波打っていないが、数はとにかく波打っていなかったので、これは結果にも影響しません。
• 数は一桁を有する場合、インデックスで桁が1（端の周りCJamの配列のインデックスループので）最初の桁であるので、2つの同一の数字で、この結果、その数はあるだろうしません波打ち。

コードを詳細に見てみましょう：

l_1=\+{_@-\}*;]_1=\+{_@*\}*;]{W>},!
l                                   "Read input.";
 _1=\+                              "Prepend second digit.";
      {_@-\}*                       "This fold gets the differences of consecutive elments.";
             ;]                     "Drop the final element and collect in an aray.";
               _1=\+                "Prepend second element.";
                    {_@*\}*         "This fold gets the products of consecutive elments.";
                           ;]       "Drop the final element and collect in an aray.";
                             {W>},  "Filter out non-negative numbers.";
                                  ! "Logical not.";

実際に数字（1を超える長さ）が波打っていないか（特に、2つの折り目を使用せずに）数字を確認するより短い方法があると確信していますが、まだ見つかりませんでした。

プロローグ87バイト

u(X) :- number_codes(X,C),f(C).
f([_,_]).
f([A,B,C|L]) :- (A<B,B>C;A>B,B<C),f([B,C|L]).

実行するには、単にgolf.plとして保存し、同じディレクトリでプロローグインタープリター（gprologなど）を開いて、次を実行します。

consult(golf).
u(101010).

それは与えないだろうtrue数はそうちょうど何も、波状である場合。

Mathematica、46バイト

#!=Sort@#&&#!=Reverse@Sort@#&[IntegerDigits@n]

例（スペースは不要です）：

# != Sort@# && # != Reverse@Sort@# &[IntegerDigits@5]
# != Sort@# && # != Reverse@Sort@# &[IntegerDigits@123]
# != Sort@# && # != Reverse@Sort@# &[IntegerDigits@132]
# != Sort@# && # != Reverse@Sort@# &[IntegerDigits@321]

(*  out *)
False  False  True  False

Scala、141133129 97バイト

def u(n:Int):Boolean=n>9&&{
val a=n%10
val b=(n/10)%10
a!=b&&n<99||(a-b*b-(n/100)%10)<0&&u(n/10)}

a = n％10、b =（n / 10）％10、c =（n / 100）％10の場合

if a > b and b < c or 
   a < b and b > c

その後a-b * b-cのいずれかであるx*-yか-x*yとxし、y正の数であり、積は両方の場合で負ですが、-x*-y or x*y（a <b <cまたはa> b> c）の積は常に正です。

コードの残りの部分は、1桁、2桁、2桁の同一の特殊なケースを処理しています。

Perl、78バイト

sub u{@_=split//,$_=shift;s/.(?=.)/($&cmp$_[$+[0]])+1/ge;chop;$#_&&!/00|1|22/}

Q、71バイト

{$[x>9;any all a=#[;(1 -1;-1 1)](#)a:1_signum(-':){"I"$x}each -3!x;0b]}

サンプル使用法：

q){$[x>9;any all a=#[;(1 -1;-1 1)](#)a:1_signum(-':){"I"$x}each -3!x;0b]} 5
0b
q){$[x>9;any all a=#[;(1 -1;-1 1)](#)a:1_signum(-':){"I"$x}each -3!x;0b]} 10101
1b
q){$[x>9;any all a=#[;(1 -1;-1 1)](#)a:1_signum(-':){"I"$x}each -3!x;0b]} 01010
1b
q){$[x>9;any all a=#[;(1 -1;-1 1)](#)a:1_signum(-':){"I"$x}each -3!x;0b]} 134679
0b
q){$[x>9;any all a=#[;(1 -1;-1 1)](#)a:1_signum(-':){"I"$x}each -3!x;0b]} 123456
0b
q){$[x>9;any all a=#[;(1 -1;-1 1)](#)a:1_signum(-':){"I"$x}each -3!x;0b]} 132436
1b

ジュリア0.6、62バイト

f(x,a=sign.(diff(digits(x))))=x>9&&-a*a[1]==(-1).^(1:endof(a))

数値trueを受け取り、Undulantの場合とそうfalseでない場合に戻ります。例えばをf(163)返しますtrue。

f(x,a=sign.(diff(digits(x))))=x>9&&-a*a[1]==(-1).^(1:endof(a))
f(x,                        )                                   # function definition
    a=sign.(diff(digits(x)))                                    # default 2nd argument is array of differences of signs of digits
                              x>9&&                             # short circuiting and to catch cases under 10
                                   -a*a[1]                      # make the first element of a always -1
                                          ==(-1).^(1:endof(a))  # check that a is an array of alternating -1 and 1 of correct length

オンラインでお試しください！