Um número ondulado é um número em que seus dígitos alternam entre cima e para baixo, como o seguinte número: 461902 ou 708143, ou mesmo 1010101, mas não 123, porque 2 <3.

Escreva um programa ou função que retorna um valor truthy se um número é ondulante , e um valor Falsas contrário. O código mais curto vence.

Nota : Os números de um dígito são uma entrada válida, mas não são considerados udulantes ; portanto, isUndulantretornam false para n <10.

J, 45

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

Uso da amostra:

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

Tenho certeza de que há uma maneira mais fina de torcer o Insert / para fazer mais do trabalho de uma só vez, mas estou sem J há meses, preciso voltar a ele.

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 e caixas de teste:

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

Dígitos únicos produzem falso :

p u[5]       # <= false

Dígitos idênticos consecutivos também retornam false :

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

J, 30 bytes

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

Uma abordagem diferente das outras respostas J.

   * / 0 <(#,] * {. * 1 _1 $ ~ #) 2 - / \ ai ": 461902
1 1
   * / 0 <(#,] * {. * 1 _1 $ ~ #) 2 - / \ ai ": 708143
1 1
   * / 0 <(#,] * {. * 1 _1 $ ~ #) 2 - / \ ai ": 1010101
1 1
   * / 0 <(#,] * {. * 1 _1 $ ~ #) 2 - / \ ai ": 123
0 0
   * / 0 <(#,] * {. * 1 _1 $ ~ #) (} .-} :) ai ": 5
0 0

Seriam 3 caracteres mais curtos se 5 fossem considerados indulantes.

(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 com pdfetex filename.tex 1324?fornece uma saída em pdf. O TeX é principalmente uma linguagem tipográfica, e a saída para stdout levaria cerca de 20 caracteres a mais. Além disso, o requisito estranho para números de um dígito (falso e não verdadeiro) leva-me 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

Isso requer o pragma língua de uso corrente (ou -Xbandeira): NoMonomorphismRestriction. Se você não admitir isso, temos que adicionar 4 caracteres e definir zassim:

z s=zipWith compare s$tail s

Sábio, 83 76 bytes

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

Teve a idéia de usar cmp (* [..]) do JBernardo. No Sage, uniq(...)é um apelido para list(set(...)).

Edit: apenas notei que para x <10 uniq(cmp(...)) == [], o que não está ativado [[1],[-1]]. Se x fosse inserido como uma string, em vez de um número inteiro, eu poderia obter outros 4 caracteres!

Python: 101 100 caracteres

Antes da minificação:

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

Após a minificação:

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

Ungolfed:

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}

Em essência, transforme o número em uma sequência e compare os caracteres adjacentes, alterando a expectativa de cada um.

K, 41 bytes

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

Por exemplo

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

Testes:

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

Descomprimido:

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.

Eu não tinha notado que minha última edição tornou a desigualdade com o cheque 0 completamente desnecessária. :-)

Resposta anterior (+ explicação):

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

Uso:

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

A resposta tem quatro partes:

1. u=.".;' ',.": Isso lê o número como uma string ":, divide-o em uma lista de caracteres precedidos por espaços ' ',., junta-os novamente ;, converte-os novamente em números ".e armazena o resultado. u=.Isso basicamente transforma 461902 em 4 6 1 9 0 2, o que acho mais fácil processar em J.

2. */2~:/\2<:/\ Isso opera com o valor armazenado em u. Ele pega cada par de caracteres e verifica se o esquerdo é menor ou igual ao direito, de 2<:/\modo que 4 6 1 9 0 2 se torna 1 0 1 0 1. Em seguida, pega o resultado disso e verifica se há desigualdade em cada par de números 2~:/\então 1 0 1 0 1 se torna 1 1 1 1. Finalmente, multiplica-os todos juntos para obter um 0 ou um 1. */Nesse ponto, poderíamos retornar a resposta se não fosse por duas coisas: um único dígito retorna 1 quando o pergunta requer um 0; e números iguais são tratados da mesma forma que 'menor que', então 461900 retorna 1 em vez de 0. Que chatice. Vamos lá ...

3. (1<#u) Isso verifica se o número de itens armazenados em u #ué maior que 1 e retorna falso se for apenas um número de um dígito.

4. (0=+/2=/\u) Isso pega cada par de números armazenados em u e verifica a igualdade 2=/\u. Em seguida, soma as respostas e verifica se possui 0.

Os resultados das partes 2, 3 e 4 são então multiplicados para (esperançosamente) produzir um 1 quando o número atender aos requisitos especificados na pergunta.

Haskell, 82 bytes

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

Experimente online!

Python, 119 108 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;}

mesmo método que meu Erlang awnser com um loop for em vez de recursão.

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)

Solução recursiva. c(r,t)verifica se o primeiro caractere de ré menor (t==-1)ou maior que o (t==1)segundo caractere e chame a verificação oposta na string reduzida.

Perl / re, 139 bytes

Fazer tudo em regex é uma má ideia.

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

Estou usando o Perl 5.12, mas acho que isso funcionará no Perl 5.10. Certamente 5.8 está fora embora.

para (qw (461902 708143 1010101 123 5)) {
    imprima "$ _ is". (/ regex louco vai aqui /? '': 'não'). "ondulado \ n";
}

461902 é ondulado
708143 é ondulado
1010101 é ondulado
123 não é ondulado
5 não é ondulado

GolfScript, 48 bytes

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

Na esperança de vencer J, minha primeira vez usando o GolfScript. Não foi bem sucedido.

JavaScript, 66 65 62 60 bytes

Pega a entrada como uma sequência, retorna truepara números não desejados, uma sequência vazia (falsey) para números de um dígito e falseoutros.

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

Tente

Execute o snippet abaixo para testar 0-9e 25 números aleatórios <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>

Explicação

Alguns truques divertidos neste, então eu acho que merece uma explicação rara para uma solução JS de mim.

()=>

Começamos, simplesmente, com uma função anônima que pega a sequência inteira como argumento quando chamada.

[s,...a]

Esse argumento é imediatamente desestruturado em 2 parâmetros: ssendo o primeiro caractere na string e asendo uma matriz que contém os caracteres restantes (por exemplo, "461902"torna s="4"- se e a=["6","1","9","0","2"]).

a+a&&

Primeiro, concatenamos aconsigo mesmo, que lança as duas ocorrências em seqüências de caracteres. Se a entrada for um número de um dígito, aficará vazia e, portanto, se tornará uma sequência vazia; uma string vazia mais uma string vazia ainda é uma string vazia e, como isso é falso no JS, paramos de processar no AND lógico e produzimos nossa string vazia. Em todos os outros casos a+a, será verdade e, portanto, continuamos na próxima parte da função.

a.every(x=>)

Nós vamos estar verificando se cada elemento xem aretornos trueao passado através de uma função.

y=s<a

Isso determina qual será nossa primeira comparação ( <ou >) e, em seguida, alternaremos a partir daí. Verificamos se a string sé menor que a matriz a, que é convertida em uma string no processo, portanto, se sé menor que o primeiro caractere ema , yserá trueou falsenão.

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

Construímos uma string com o valor atual de sno início e xno final. No meio, indexamos a string "<>"incrementandoy , seu valor booleano inicial em um número inteiro e modulo em 2, fornecendo-nos 0ou 1.

eval()

Avalie essa corda.

s=x

Finalmente, passamos um segundo argumento para eval, que ele ignora, e o usamos para definir o valor de spara o valor atual de xpara a próxima iteração.

PowerShell, 88

Ingênuo e trivial. Mais tarde vou jogar golfe.

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

Meus casos de teste .

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}

Você só precisa passar um argumento. Provavelmente eu poderia jogar isso ainda mais com um loop 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

O CJam é mais novo que esse desafio, portanto não compete pela marca de seleção verde, mas não é um vencedor de qualquer maneira (embora eu tenha certeza de que isso pode realmente ser praticado bastante).

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

Teste aqui.

Como funciona

Em primeiro lugar, estou fazendo alguma manipulação de string (seguida de eval) para salvar 5 bytes em código duplicado:

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

Então, com efeito, meu código é

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

Primeiro, aqui está como eu lido com o caso especial estranho de um único dígito. Copio o dígito no índice 1e o prefixo ao número. Precisamos distinguir 3 casos:

• Os dois primeiros dígitos são diferentes 12..., então obtemos212... , então o início é ondulado e não afeta se o número inteiro é ondulado.
• Os dois primeiros dígitos são os mesmos 11..., então, obtemos 111.... Agora, o início não é ondulado, mas o número não era ondulado, portanto, isso também não afetará o resultado.
• Se o número tiver apenas um dígito, o dígito no índice 1será o primeiro (porque a indexação da matriz do CJam faz um loop no final), portanto, isso resulta em dois dígitos idênticos e o número não é ondulado.

Agora, olhando o código em detalhes:

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

Tenho certeza de que existe uma maneira mais curta de verificar os dígitos (de comprimento maior que 1) para saber se eles são ondulados (em particular, sem usar duas dobras), mas ainda não consegui encontrá-lo.

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 executá-lo, salve-o como golf.pl, abra um intérprete de prólogo (por exemplo, gprolog) no mesmo diretório e faça:

consult(golf).
u(101010).

Ele lhe dará truese o número é ondulante, caso contrário, apenas não.

Mathematica, 46 bytes

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

Exemplos (espaços não são necessários):

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

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

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

Então a-b * b-cé x*-you -x*ycom xe ycomo números positivos, e o produto é negativo nos dois casos, mas por -x*-youx*y (a <b <c ou a> b> c) o produto é sempre positivo.

O restante do código está lidando com casos especiais: um dígito, dois dígitos, dois 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 da amostra:

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

Pega um número, retorna truepara Undulant e falsepara não. Por exemplo, f(163)retornos 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

Experimente online!