Un número ondulante es un número donde sus dígitos alternan entre arriba y abajo como el siguiente número: 461902 o 708143, o incluso 1010101, pero no 123, porque 2 <3.

Escriba un programa o función que devuelva un valor verdadero si un número es ondulante , y un valor falso de lo contrario. El código más corto gana.

Nota : los números de un solo dígito son una entrada válida pero no se consideran udulantes , por lo tanto, isUndulantdevuelve falso para n <10.

J, 45

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

Uso de la muestra:

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

Estoy bastante seguro de que hay una mejor manera de torcer Insert /para hacer más trabajo de una vez, pero he estado sin J durante meses, necesito volver a hacerlo.

Ruby, 72 70 caracteres

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

Uso y casos de prueba:

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

Los dígitos individuales producen falso :

p u[5]       # <= false

Los dígitos idénticos consecutivos también devuelven falso :

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

J, 30 bytes

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

Un enfoque diferente que las otras respuestas de 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
   * / 0 <(#,] * {. * 1 _1 $ ~ #) (} .-} :) ai ": 5
0 0

Sería 3 caracteres más corto si 5 se consideraran ondulantes.

(pdf) eTeX, 129 caracteres

\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

Compilar con pdfetex filename.tex 1324?da una salida en pdf. TeX es principalmente un lenguaje de composición tipográfica, y la salida en lugar de stdout tomaría alrededor de 20 caracteres más. Además, el extraño requisito de números de un dígito (falso en lugar de verdadero) me lleva 26 caracteres.

Haskell, 88 77 73 65 caracteres

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

Esto requiere que el pragma idioma de uso común (o -Xbandera): NoMonomorphismRestriction. Si no admite eso, tenemos que agregar 4 caracteres y definir zasí:

z s=zipWith compare s$tail s

Salvia, 83 76 bytes

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

Se me ocurrió la idea de usar cmp (* [..]) de JBernardo. En sabio, uniq(...)es un alias para list(set(...)).

Editar: acabo de notar que para x <10 uniq(cmp(...)) == [], que no está activado [[1],[-1]]. Si x se ingresara como una cadena, en lugar de un entero, ¡podría obtener otros 4 caracteres!

Python: 101 100 caracteres

Antes de la minificación:

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

Después de la minificación:

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 caracteres

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

Sin golf:

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 caracteres

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}

En esencia, convierta el número en una cadena y compare los caracteres adyacentes, volteando las expectativas para cada uno.

K, 41 bytes

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

P.ej

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

CoffeeScript, 98 67 53 bytes

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

Pruebas:

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

Sin comprimir:

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 bytes

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

Uso como antes.

No me había dado cuenta de que mi última edición hizo que la desigualdad con el control 0 fuera completamente innecesaria. :-)

Respuesta anterior (+ explicación):

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

Uso:

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

La respuesta tiene cuatro partes:

1. u=.".;' ',.": Esto lee el número como una cadena ":, lo divide en una lista de caracteres precedidos por espacios ' ',., lo vuelve a unir ;, lo convierte de nuevo en números ".y luego almacena el resultado u=.Esto básicamente convierte 461902 en 4 6 1 9 0 2, lo cual me parece más fácil procesar en J.

2. */2~:/\2<:/\ Esto opera en el valor almacenado en u. Toma cada par de caracteres y comprueba si el izquierdo es menor o igual que el derecho, 2<:/\por lo que 4 6 1 9 0 2 se convierte en 1 0 1 0 1. Luego toma el resultado de esto y verifica la desigualdad en cada par de números 2~:/\así que 1 0 1 0 1 se convierte en 1 1 1 1. Finalmente, los multiplica para obtener un 0 o un 1. */En este punto, podríamos devolver la respuesta si no fuera por 2 cosas: un solo dígito devuelve 1 cuando el la pregunta requiere un 0; y números iguales se tratan igual que 'menor que', por lo que 461900 devuelve 1 en lugar de 0. Bummer. En vamos ...

3. (1<#u) Esto comprueba si el número de elementos almacenados en u #ues mayor que 1 y devuelve falso si es solo un número de un solo dígito.

4. (0=+/2=/\u) Esto toma cada par de números almacenados en u y verifica la igualdad 2=/\u. Luego suma las respuestas y comprueba si tiene 0.

Los resultados de las partes 2, 3 y 4 se multiplican juntos para (con suerte) producir un 1 cuando el número cumple con los requisitos especificados en la pregunta.

Haskell, 82 bytes

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

Pruébalo en línea!

Python, 119108 bytes

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 caracteres

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 caracteres

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

mismo método que mi Erlang awnser con un bucle for en lugar de recursividad.

Python 105 101 100 caracteres

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)

Solución recursiva. c(r,t)comprueba si el primer carácter de res menor (t==-1)o mayor que el (t==1)segundo carácter, y llama al control opuesto en la cadena acortada.

Perl / re, 139 bytes

Hacer todo en expresiones regulares es una mala idea.

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

Estoy usando Perl 5.12 pero creo que esto funcionará en Perl 5.10. Sin embargo, estoy bastante seguro de que 5.8 está fuera.

para (qw (461902 708143 1010101 123 5)) {
    imprime "$ _ is". (/ Regex loco va aquí /? '': 'no'). "ondulante \ n";
}

461902 es ondulante
708143 es ondulante
1010101 es ondulante
123 no es ondulante
5 no es ondulante

GolfScript, 48 bytes

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

Con la esperanza de vencer a J, mi primera vez usando GolfScript. No tuvo mucho éxito.

JavaScript, 66 65 62 60 bytes

Toma la entrada como una cadena, regresa truepara números ondulantes, una cadena vacía (falsey) para números de un solo dígito y de falseotra manera.

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

Intentalo

Ejecute el fragmento a continuación para probar 0-9y 25 números aleatorios <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>

Explicación

Algunos trucos divertidos en este caso, así que creo que justifica una explicación rara para mí de una solución JS.

()=>

Comenzamos, simplemente, con una función anónima que toma la cadena entera como argumento cuando se llama.

[s,...a]

Ese argumento se desestructura de inmediato en 2 parámetros: sser el primer carácter de la cadena y aser una matriz que contiene los caracteres restantes (por ejemplo, se "461902"convierte en s="4"y a=["6","1","9","0","2"]).

a+a&&

Primero, nos concatenamos aconsigo mismos, lo que convierte ambas ocurrencias en cadenas. Si la entrada es un número de un solo dígito, aestará vacío y, por lo tanto, se convertirá en una cadena vacía; una cadena vacía más una cadena vacía sigue siendo una cadena vacía y, como eso es falsey en JS, detenemos el procesamiento en el AND lógico y sacamos nuestra cadena vacía. En todos los demás casos a+aserá veraz y, por lo tanto, continuaremos con la siguiente parte de la función.

a.every(x=>)

Comprobaremos si cada elemento xen adevuelve truecuando se pasa a través de una función.

y=s<a

Esto determina cuál será nuestra primera comparación ( <o >) y luego alternaremos desde allí. Verificamos si la cadena ses menor que la matriz a, que se convierte en una cadena en el proceso, por lo que, si ses menor que el primer carácter a, yserá trueo falseno.

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

Construimos una cadena con el valor actual de sal principio y xal final. En el medio, indexamos en la cadena "<>"incrementando y, convirtiendo su valor booleano inicial en un número entero, y el módulo en 2, dándonos 0o 1.

eval()

Evalúa esa cuerda.

s=x

Finalmente, pasamos un segundo argumento a eval, que ignora, y lo usamos para establecer el valor de sal valor actual de xpara la próxima iteración.

PowerShell, 88

Ingenuo y trivial. Jugaré golf más tarde.

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

Mis casos de prueba .

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}

Solo necesita pasarle un argumento. Probablemente podría jugar más golf con un bucle for.

Erlang, 137 123 118 caracteres

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 bytes

CJam es más nuevo que este desafío, por lo que no compite por la marca de verificación verde, pero de todos modos no es un ganador (aunque estoy seguro de que en realidad se puede jugar bastante).

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

Pruébalo aquí.

Cómo funciona

En primer lugar, estoy haciendo una manipulación de cadenas (seguida de eval) para guardar 5 bytes en código duplicado:

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

En efecto, mi código es

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

Primero, así es como trato con el extraño caso especial de un solo dígito. Copio el dígito en el índice 1y lo antepongo al número. Necesitamos distinguir 3 casos:

• Los primeros dos dígitos son diferentes, como 12..., luego obtenemos 212..., por lo que el inicio es ondulante y no afectará si el número completo es ondulante.
• Los dos primeros dígitos son iguales 11..., entonces, obtenemos111... . Ahora el inicio no es ondulante, pero el número no fue ondulante de todos modos, por lo que esto tampoco afectará el resultado.
• Si el número solo tiene un dígito, el dígito en el índice 1será el primer dígito (porque la indexación de la matriz de CJam gira alrededor del final), por lo que esto da como resultado dos dígitos idénticos, y el número no es ondulante.

Ahora mirando el código en detalle:

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

Estoy seguro de que hay una forma más corta de verificar los dígitos (de longitud mayor 1) para ver si son ondulantes (en particular, sin usar dos pliegues), pero aún no pude encontrarlo.

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

Para ejecutarlo, simplemente guárdelo como golf.pl, abra un intérprete de prólogo (por ejemplo, gprolog) en el mismo directorio y luego haga lo siguiente:

consult(golf).
u(101010).

Dará truesi el número es ondulante, de lo contrario simplemente no.

Mathematica, 46 bytes

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

Ejemplos (no se requieren espacios):

# != 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 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)}

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

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

Entonces a-b * b-ces x*-yo -x*ycon xy ycomo números positivos, y el producto es negativo en ambos casos, pero para -x*-yox*y (a <b <c o a> b> c) el producto siempre es positivo.

El resto del código maneja casos especiales: un dígito, dos dígitos, dos dígitos idénticos.

Perl, 78 bytes

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

Q, 71 bytes

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

Uso de la muestra:

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

Julia 0.6 , 62 bytes

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

Toma un número, regresa truepor Undulant y falsepor no. Por ejemplo, f(163)vuelve 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

Pruébalo en línea!