Волнисто число является числом , где его цифры чередуются между вверх и вниз , как показано в следующем номер: 461902 или 708143, или даже 1010101, но не 123, потому что 2 <3.

Напишите программу или функцию, которая возвращает истинное значение, если число ненулевое , и ложное значение в противном случае. Самый короткий код выигрывает.

Примечание. Однозначные числа являются допустимым вводом, но не считаются неправильными , поэтому isUndulantвозвращает значение false при n <10.

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, /чтобы выполнять большую часть работы на ходу, но я уже несколько месяцев не работаю, мне нужно вернуться к этому.

Рубин, 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

Единственные цифры дают ложь :

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

Было бы на 3 символа короче, если бы 5 считались ненужными.

(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 символов. Также странное требование для однозначных чисел (false, а не true) занимает у меня 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]]

Есть идея использовать cmp (* [..]) из JBernardo. В Sage uniq(...)это псевдоним для list(set(...)).

Изменить: только что заметил, что для х <10 uniq(cmp(...)) == [], который не включен [[1],[-1]]. Если бы x было введено как строка, а не как целое число, я мог бы получить еще 4 символа!

Python: 101 100 символов

До минификации:

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

Питон, 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])

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 символов

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}

По сути, превратите число в строку и сравните соседние символы, отражая ожидание для каждого.

К, 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

Ответ состоит из четырех частей:

1. u=.".;' ',.": Это читает число в виде строки ":, разбивает его на список символов, перед которыми стоят пробелы ' ',., сшивает его обратно ;, преобразует его обратно в числа ".и затем сохраняет результат. u=.Это в основном превращает 461902 в 4 6 1 9 0 2, который я считаю легче обрабатывать в J.

2. */2~:/\2<:/\ Это действует на значение, хранящееся в вас. Он берет каждую пару символов и проверяет, меньше ли левый или равен правому, 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 вещи: одна цифра возвращает 1, когда вопрос требует 0; и равные числа обрабатываются так же, как «меньше чем», поэтому 461900 возвращает 1 вместо 0. Облом. На мы идем ...

3. (1<#u) Это проверяет, больше ли количество элементов, хранящихся в u, #uчем 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

Попробуйте онлайн!

Питон, 119 108 байт

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]

Питон, 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;}

тот же метод, что и у моего Erlang awnser с циклом for, а не с рекурсией.

Python 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)проверяет, является ли первый символ 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 вышел.

для (qw (461902 708143 1010101 123 5)) {
    выведите «$ _ is». (/ сумасшедшее регулярное выражение идет сюда /? '': 'not') «волнистый \ п»;
}

461902 является безвредным
708143 является ненулевой
1010101 - это волнистость
123 не лишен
5 не отменяет

GolfScript, 48 байт

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

Надеясь победить J, я впервые использую GolfScript. Не совсем удалось.

JavaScript, 66 65 62 60 байт

Принимает ввод в виде строки, возвращает trueдля неоправданных чисел, пустую строку (Falsey) для однозначных чисел и в falseпротивном случае.

([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себя, что приводит оба вхождения к строкам. Если ввод представляет собой однозначное число, то оно aбудет пустым и, следовательно, станет пустой строкой; пустая строка плюс пустая строка по-прежнему является пустой строкой, и, поскольку в JS это неправильно, мы прекращаем обработку в логическом И и выводим нашу пустую строку. Во всех остальных случаях 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 , который он игнорирует, и используем его, чтобы установить 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}

Вам нужно только передать один аргумент. Я мог бы, вероятно, играть в гольф дальше с петлей для.

Эрланг, 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>},!

Проверьте это здесь.

Как это устроено

Во-первых, я делаю некоторые манипуляции со строками (за которыми следует eval), чтобы сохранить 5 байтов в дубликате кода:

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

Итак, по сути мой код

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

Во-первых, вот как я справляюсь со странным частным случаем одной цифры. Я копирую цифру по индексу1 и добавляю ее к числу. Нужно выделить 3 случая:

• Первые две цифры разные, как 12... , потом получаем212... , поэтому начало не является избыточным, и не влияет на то, является ли полное число ненужным.
• Первые две цифры такие же, как 11... и тогда, мы получаем 111.... Теперь начало не отменено, но число все равно не уменьшилось, так что это также не повлияет на результат.
• Если число имеет только одну цифру, цифра в индексе 1будет первой цифрой (потому что индексирование массива CJam зацикливается вокруг конца), так что это приводит к двум одинаковым цифрам, и число не является лишним.

Теперь подробно рассмотрим код:

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) на предмет того, являются ли они ненульными (в частности, без использования двух сгибов), но я пока не смог их найти.

Пролог 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, 141 133 129 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илиx*y (a <b <c или a> b> c) произведение всегда положительно.

Остальная часть кода обрабатывает особые случаи: одна цифра, две цифры, две идентичные цифры.

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

Попробуйте онлайн!