Liczby niezbyt wyraźne

16

Falujący jest to numer gdzie cyfr na przemian w górę i w dół , jak na nr 461902 i 708143, lub nawet 1010101, a nie 123, ponieważ 2 <3.

Napisz program lub funkcję, która zwraca prawdziwą wartość, jeśli liczba jest niedulantna , a wartość fałsz w przeciwnym razie. Najkrótszy kod wygrywa.

Uwaga : Liczby jednocyfrowe są prawidłowymi danymi wejściowymi, ale nie są uważane za udulant , dlatego isUndulantzwraca wartość false dla n <10.

Leonardo
źródło
Liczba wprowadzana jako ciąg, liczba całkowita, liczba zmiennoprzecinkowa ...?
przestał się obracać przeciwnie do zegara
1
Jaki jest tutaj cel? Code-golf (najkrótsza funkcja)?
Alexandru
1
@JBernardo: Myślę, że zachowanie prawdziwe lub nieokreślone, ponieważ byłby to lepszy podstawowy przypadek rekurencji.
Joey Adams,
4
Twoja definicja numeru niedozwolonego nie jest zgodna ze standardową definicją: mathworld.wolfram.com/UndicingNumber.html . Czy to celowe?
mellamokb
9
Moje rozwiązanie mogłoby być o 16% mniejsze, gdyby przypadek podstawowy był prawdziwy (co miałoby sens IMHO).
eternalmatt

Odpowiedzi:

6

J, 45

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

Przykładowe użycie:

   *./(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

Jestem prawie pewien, że istnieje lepszy sposób na skręcenie Wstawki, /aby wykonać więcej pracy za jednym zamachem, ale od miesięcy nie mam J, muszę do tego wrócić.

JB
źródło
Trudno będzie pokonać J w tym problemie. fajne rozwiązanie!
leonardo
@ leonardo dzięki!
JB
6

Ruby, 72 70 znaków

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

Zastosowanie i przypadki testowe:

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

Pojedyncze cyfry dają fałsz :

p u[5]       # <= false

Kolejne identyczne cyfry również zwracają false :

p u[66]      # <= false
p u[1221]    # <= false
Howard
źródło
6

J, 30 bajtów

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

Inne podejście niż inne odpowiedzi 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

Byłyby 3 znaki krótsze, gdyby 5 uważano za niedorzeczne.

efemeryczny
źródło
Cóż, przynajmniej mogę się pocieszyć myślą, że mam prowadzenie przez godzinę. :-)
Gareth
5

(pdf) eTeX, 129 znaków

\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

Kompilacja z pdfetex filename.tex 1324?daje wynik pdf. TeX jest przede wszystkim językiem składu, a wyjście na standardowe wyjście zajmie około 20 znaków więcej. Również dziwne wymaganie dla liczb jednocyfrowych (raczej fałszywe niż prawdziwe) zabiera mi 26 znaków.

Bruno Le Floch
źródło
5

Haskell, 88 77 73 65 znaków

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

Wymaga to powszechnie używany język (lub pragmy -Xflagę) NoMonomorphismRestriction. Jeśli nie przyznasz się do tego, musimy dodać 4 znaki i zdefiniować w zten sposób:

z s=zipWith compare s$tail s
MtnViewMark
źródło
Jestem tak wściekły, że pobiłeś moje 104-karatowe rozwiązanie. u n=length s>1&&(a[GT,LT]||a[LT,GT])where s=show n;z=q compare s$tail s;w=q(==)z;q=zipWith;a=and.w.cycleTo trochę eleganckie. zipWithraz z, comparetak jak ty, potem zipWithznowu z (==)i cycle[GT,LT]lub cycle[LT,GT]jako drugi argument.
eternalmatt
możesz wstawić w, ponieważ tail>>=zipWith compareskróciłoby to kilka bajtów.
dumny haskeller
grałem też w krótszą wersję q:q[]=0<1;q(a:b:s)|a/=b,a/=EQ=q$b:s;q _=0>1
dumny haskeller
oto jeszcze krótsza wersja: q s=and$all(/=EQ)s:zipWith(/=)s(tail s)
dumny haskeller
@proudhaskeller - żadna wersja nie przechodzi wszystkich testów. Oba kończą się niepowodzeniem 3 (powinny być fałszywe), a pierwszy zawodzi wiele innych, takich jak 32 i
101010101.
4

Sage, 83 76 bajtów

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

Wpadłem na pomysł użycia cmp (* [..]) od JBernardo. W Sageuniq(...) jest pseudonimem list(set(...)).

Edycja: właśnie zauważyłem, że dla x <10 uniq(cmp(...)) == [], która nie jest włączona [[1],[-1]]. Gdyby x wprowadzono jako ciąg, zamiast liczby całkowitej, mógłbym uzyskać kolejne 4 znaki!

boothby
źródło
Miałem pomysł, aby użyć sum(uniq(...))^2, sum([1,-1]) = 0a sumy kwadratów singletonów [1] i [-1] do 1. Niestety nie udaje się to na trzykrotnie powtarzanej cyfrze; 1011101.
stoisko
Ładny. Powinienem nauczyć się szałwii. BTW, właśnie zdałem sobie sprawę, że backticks się dołączą, Ljeśli liczba jest większa niż 2 ** 32 w Pythonie i wpływa na wynik. Czy tak się dzieje na Sage?
JBernardo,
Tak, Sage sprawia, że ​​gra w golfa jest przyjemna ... na przykład, jego absurdalny czas uruchamiania spędza na importowaniu ogromnego drzewa modułów. Klasa Sage Integer nie przejmuje się tym, Lponieważ Sage jest przygotowanym pythonem; 1234 -> Liczba całkowita („1234”). Możesz przeskoczyć prawo do korzystania Sage tutaj: sagenb.org
Boothby
4

Python: 101 100 znaków

Przed minifikacją:

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

Po minifikacji:

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

źródło
3

Python, 134 129 znaków

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

Nie golfowany:

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)
JBernardo
źródło
3

JavaScript, 88 znaków

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}

Zasadniczo zamień liczbę na ciąg znaków i porównaj sąsiednie postacie, zmieniając oczekiwania dla każdego z nich.

DocMax
źródło
2
W JavaScript funkcja nie potrzebuje nazwy, a pytanie wyraźnie pyta o funkcję, dzięki czemu można zapisać dwa znaki.
Ry-
3

K, 41 bajtów

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

Na przykład

{(x>9)&~max(=). 1_'-':'1_'(<':;>':)@\:$x}1212130659
1b
skeevey
źródło
3

CoffeeScript, 98 67 53 bajty

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

Testy:

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

Nieskompresowane:

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
Ricardo Tomasi
źródło
3

J, 44 39 36 31 bajtów

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

Wykorzystanie jak poprzednio.

Nie zauważyłem, że moja ostatnia edycja sprawiła, że ​​nierówność z czekiem 0 była zupełnie niepotrzebna. :-)

Poprzednia odpowiedź (+ wyjaśnienie):

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

Stosowanie:

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

Odpowiedź składa się z czterech części:

  1. u=.".;' ',.": Odczytuje liczbę jako ciąg znaków ":, dzieli ją na listę znaków poprzedzoną spacjami ' ',., łączy ją z powrotem ;, konwertuje z powrotem na liczby, ".a następnie zapisuje wynik. u=.Zasadniczo zamienia 461902 na 4 6 1 9 0 2, co jest dla mnie łatwiejsze przetwarzać w J.

  2. */2~:/\2<:/\ Działa to na wartości zapisanej w u. Bierze każdą parę znaków i sprawdza, czy lewa jest mniejsza lub równa prawej, 2<:/\więc 4 6 1 9 0 2 staje się 1 0 1 0 1. Następnie bierze wynik tego i sprawdza każdą parę liczb pod kątem nierówności 2~:/\więc 1 0 1 0 1 staje się 1 1 1 1. W końcu mnoży je wszystkie razem, aby uzyskać 0 lub 1 */W tym momencie moglibyśmy zwrócić odpowiedź, gdyby nie dwie rzeczy: pojedyncza cyfra zwraca 1, gdy pytanie wymaga 0; i równe liczby są traktowane tak samo jak „mniej niż”, więc 461900 zwraca 1 zamiast 0. Bummer. Jedziemy ...

  3. (1<#u) To sprawdza, czy liczba elementów przechowywanych u #ujest większa niż 1 i zwraca false, jeśli jest to tylko jedna cyfra.

  4. (0=+/2=/\u) Pobiera każdą parę liczb zapisanych wu i sprawdza równość 2=/\u. Następnie sumuje odpowiedzi i sprawdza, czy ma 0.

Wyniki części 2, 3 i 4 są następnie mnożone razem, aby (miejmy nadzieję) otrzymać 1, gdy liczba spełnia wymagania określone w pytaniu.

Gareth
źródło
Dobra robota, ponownie obejmująca prowadzenie, ale właśnie pożyczyłem od ciebie sztuczkę!
ephemient
(Biorąc to pod uwagę, myślę, że możesz wziąć mnie, a.i.":by ogolić jeszcze kilka postaci).
efemituje
Niestety prawdopodobnie będę musiał ponownie wprowadzić kontrolę nierówności - moja odpowiedź kończy się teraz niepowodzeniem dla 11, 22, 33, 44 itd.
Gareth
3

Haskell, 82 bajty

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

Wypróbuj online!

Thomas Eding
źródło
W tym rozwiązaniu liczę tylko 83 znaki. (Być może korzystasz z systemu Windows? Napisz plik z zakończeniami linii unix, co jest zgodne z prawem Haskell.)
MtnViewMark,
Dzięki, użyłem „wc”, aby policzyć moje postacie na Cygwin. Liczę 82 znaki. Użyłem następującego kodu, ponieważ wc wydaje się wyświetlać dodatkowy znak. (Vim nie pokazuje końca nowej linii, ale notatnik ma ...) readFile "Undulant.hs" >>= print . length . dropWhile (== '\n') . reverse . filter (/= '\r')
Thomas Eding
c=cycle[(<),(>)]można skrócić do c=(<):(>):c.
Laikoni
1
zipWith3($)l(show n)$tail$show nmoże być zipWith3($)l=<<tail$show ni ((>):c)może być tail c. 70 bajtów razem: wypróbuj online!
Laikoni
3

Python, 119 108 bajtów

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]
Cyryl
źródło
2
Nice use of xor. You can cut quite a few characters out with ... for a,b in zip(t,t[1:]) rather than using ranges. Also, you don't need the brackets in all([...]) -- Python makes a generator when it finds (... for ...), even if the parentheses are for a function call.
boothby
Thank you very much for your advice! They have been very valuable! -20 chars
Kirill
Very nice solution. Few more characters x>9 and all(i^j for i,j in zip(l,l[1:])) and remove if l else False.
Ante
1
It is not working in all cases. Two cases are problematic: only 2 digits (e.g. 11), and last 2 digits are same and larger than one before (e.g. 12155). First problem is since there is no testing if x<100. Second is because 'one way comparison'. It can be fix with cmp(i,j) and instead i^j set i*j<0, and testing and l[0]!=0. Few more characters :-/
Ante
1
Hmmm... print saves one character over return, but is it legitimate? The spec does ask for a function that "returns".
2

Python, 155 chars

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]))
Keith Randall
źródło
2

C++, 94 chars

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

same method as my Erlang awnser with a for loop rather than recursion.

Scott Logan
źródło
2

Python 105 101 100 chars

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)

Recursive solution. c(r,t) checks if first char of r is less (t==-1) or greater (t==1) of second char, and call opposite check on shortened string.

Ante
źródło
Nice. You can save a character in the first line by removing 0, and you can save three characters on the second line by writing u=lambda x:x>9 and c(`x`,cmp(*`x`[:2])or 1)
Tnx. I didn't like any() from the beginning :-)
Ante
You can save one more by writing x>9and.
2

Perl/re, 139 bytes

Doing everything in regex is kind of a bad idea.

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

I'm using Perl 5.12 but I think this will work on Perl 5.10. Pretty sure 5.8 is out though.

for (qw(461902 708143 1010101 123 5)) {
    print "$_ is " . (/crazy regex goes here/ ? '' : 'not ') . "undulant\n";
}

461902 is undulant
708143 is undulant
1010101 is undulant
123 is not undulant
5 is not undulant
ephemient
źródło
2

GolfScript, 48 bytes

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

Hoping to beat J, my first time using GolfScript. Didn't quite succeed.

ephemient
źródło
2

JavaScript, 66 65 62 60 bytes

Takes input as a string, returns true for undulant numbers, an empty string (falsey) for single digit numbers and false otherwise.

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

Try it

Run the Snippet below to test 0-9 and 25 random numbers <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>


Explanation

A few fun little tricks in this one so I think it warrants a rare explanation to a JS solution from me.

()=>

We start, simply, with an anonymous function which takes the integer string as an argument when called.

[s,...a]

That argument is immediately destructured into 2 parameters: s being the first character in the string and a being an array containing the remaining characters (e.g. "461902" becomes s="4" and a=["6","1","9","0","2"]).

a+a&&

First, we concatenate a with itself, which casts both occurrences to strings. If the input is a single digit number then a will be empty and, therefore, become and empty string; an empty string plus an empty string is still an empty string and, because that's falsey in JS, we stop processing at the logical AND and output our empty string. In all other cases a+a will be truthy and so we continue on to the next part of the function.

a.every(x=>)

We'll be checking if every element x in a returns true when passed through a function.

y=s<a

This determines what our first comparison will be (< or >) and then we'll alternate from there. We check if the string s is less than the array a, which gets cast to a string in the process so, if s is less than the first character in a, y will be true or false if it's not.

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

We build a string with the current value of s at the beginning and x at the end. In between, we index into the string "<>" by incrementing y, casting its initial boolean value to an integer, and modulo by 2, giving us 0 or 1.

eval()

Eval that string.

s=x

Finally, we pass a second argument to eval, which it ignores, and use it to set the value of s to the current value of x for the next iteration.

Shaggy
źródło
1

PowerShell, 88

Naïve and trivial. I will golf later.

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

My test cases.

Joey
źródło
1

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}

You only need to pass it one argument. I could probably golf this further with a for loop.

Ry-
źródło
(d>=l -> d>0) and (d<=l -> d<2) perhaps? I'm not looking closely, as perhaps d might contain fractional parts that might skew it.
Thomas Eding
@trinithis: That's a lowercase L, not a 1. Thanks though!
Ry-
Where's DejaVu Sans Mono or Bitstream Vera Sans Mono when you need it? Perhaps I need to customize stackoverflow with some custom css or a user script...
Thomas Eding
@trinithis: I agree, the font choice isn't that great. Bolding doesn't stand out enough...
Ry-
1

Erlang, 137 123 118 chars

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)).
Scott Logan
źródło
Won't this return True so long as there has been at least one up and one down transition anywhere? Won't it return True for, say 1234321?
MtnViewMark
@ MtnViewMark, yeah it did thanks, I misunderstood the question fixed now hopefully.
Scott Logan
1

CJam, 30 bytes

CJam is newer than this challenge, so this does not compete for the green checkmark, but it's not a winner anyway (although I'm sure this can actually be golfed quite a bit).

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

Test it here.

How it works

Firstly, I'm doing some string manipulation (followed by eval) to save 5 bytes on duplicate code:

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

So in effect my code is

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

First, here is how I deal with the weird special case of a single digit. I copy the digit at index 1 and prepend it to the number. We need to distinguish 3 cases:

  • The first two digits are different, like 12..., then we get 212..., so the start is undulant, and won't affect whether the entire number is undulant.
  • The first two digits are the same, like 11..., then we get 111.... Now the start is not undulant, but the number wasn't undulant anyway, so this won't affect the result either.
  • If the number only has one digit, the digit at index 1 will be the first digit (because CJam's array indexing loops around the end), so this results in two identical digits, and the number is not undulant.

Now looking at the code in detail:

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.";

I'm sure there is a shorter way to actually check digits (of length greater 1) for whether they are undulant (in particular, without using two folds), but I couldn't find it yet.

Martin Ender
źródło
1

Prolog 87 bytes

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

To run it, just save it as golf.pl, open a prolog interpreter (e.g. gprolog) in the same directory then do:

consult(golf).
u(101010).

It will give true if the number is undulant, otherwise just no.

pgy
źródło
1

Mathematica, 46 bytes

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

Examples (spaces are not required):

# != 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
DavidC
źródło
1

Scala, 141 133 129 97 bytes

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

With a = n % 10, b = (n/10) % 10, c = (n/100) % 10

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

Then a-b * b-c is either x*-y or -x*y with x and y as positive numbers, and the product is in both cases negative, but for -x*-y or x*y (a < b < c or a > b > c) the product is always positive.

The rest of the code is handling special cases: one digit, two digits, two identical digits.

user unknown
źródło
1

Perl, 78 bytes

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

Q, 71 bytes

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

Sample usage:

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
tmartin
źródło
You can logic away the if {(x>9)&any all a=#[;(1 -1;-1 1)](#)a:1_signum(-':)("I"$')($)x} gives 62
skeevey
Never seen ($) syntax for string before and the logic is a nice touch.
tmartin
1

Julia 0.6, 62 bytes

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

Takes in a number, returns true for Undulant, and false for not. Eg f(163) returns 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

Try it online!

gggg
źródło