Eine undulierende Zahl ist eine Zahl, deren Ziffern wie die folgende Zahl zwischen hoch und runter wechseln : 461902 oder 708143 oder sogar 1010101, aber nicht 123, weil 2 <3.

Schreiben Sie ein Programm oder eine Funktion, die einen Wahrheitswert zurückgibt, wenn eine Zahl undulant ist , und ansonsten einen falschen Wert. Der kürzeste Code gewinnt.

Hinweis : Einstellige Zahlen sind eine gültige Eingabe, werden jedoch nicht als udulant angesehen und geben daher isUndulantfalse für n <10 zurück.

J, 45

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

Beispielgebrauch:

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

Ich bin mir ziemlich sicher, dass es eine feinere Möglichkeit gibt, Insert /zu drehen , um mehr von der Arbeit in einem Durchgang zu erledigen, aber ich bin seit Monaten j-weniger, ich muss darauf zurückkommen.

Ruby, 72 bis 70 Zeichen

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

Verwendung und Testfälle:

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

Einzelne Ziffern ergeben falsch :

p u[5]       # <= false

Aufeinanderfolgende identische Ziffern geben ebenfalls false zurück :

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

J, 30 Bytes

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

Ein anderer Ansatz als der andere J antwortet.

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

Wäre 3 Zeichen kürzer, wenn 5 als undulant angesehen würden.

(pdf) eTeX, 129 Zeichen

\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

Kompilieren mit pdfetex filename.tex 1324?gibt eine PDF-Ausgabe aus. TeX ist in erster Linie eine Schriftsprache, und die Ausgabe auf stdout würde etwa 20 Zeichen mehr erfordern. Auch die seltsame Forderung nach einstelligen Zahlen (eher falsch als wahr) erfordert 26 Zeichen.

Haskell, 88 77 73 65 Zeichen

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

Dies erfordert die häufig verwendete Sprache Pragma (oder -XFlag): NoMonomorphismRestriction. Wenn Sie das nicht zugeben, müssen wir 4 Zeichen hinzufügen und so definieren z:

z s=zipWith compare s$tail s

Salbei, 83 76 Bytes

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

Ich hatte die Idee, cmp (* [..]) von JBernardo zu verwenden. In Sage uniq(...)ist ein Alias ​​für list(set(...)).

Bearbeiten: gerade bemerkt, dass für x <10 uniq(cmp(...)) == [], die nicht eingeschaltet ist [[1],[-1]]. Wenn x als Zeichenkette anstelle einer ganzen Zahl eingegeben würde, könnte ich weitere 4 Zeichen herausholen!

Python: 101 100 Zeichen

Vor der Verkleinerung:

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

Nach der Verkleinerung:

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 Zeichen

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 Zeichen

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}

Verwandeln Sie die Zahl im Wesentlichen in eine Zeichenfolge und vergleichen Sie benachbarte Zeichen.

K, 41 Bytes

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

Z.B

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

CoffeeScript Früher 98 67 53 Bytes

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

Tests:

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

Unkomprimiert:

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-/\".;' ',.":

Verwendung wie zuvor.

Ich hatte nicht bemerkt, dass meine letzte Änderung die Ungleichung mit 0-Check völlig unnötig machte. :-)

Vorherige Antwort (+ Erklärung):

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

Verwendung:

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

Die Antwort besteht aus vier Teilen:

1. u=.".;' ',.": Dies liest die Zahl als Zeichenkette ein ":, teilt sie in eine Liste von Zeichen mit vorangestellten Leerzeichen ' ',.auf ;, setzt sie wieder zusammen , konvertiert sie zurück in Zahlen ".und speichert dann das Ergebnis. u=.Dies macht 461902 im Grunde genommen zu 4 6 1 9 0 2, was ich leichter finde zu verarbeiten in J.

2. */2~:/\2<:/\ Dies funktioniert mit dem in u gespeicherten Wert. Es nimmt jedes Zeichenpaar und prüft, ob das linke kleiner oder gleich dem rechten ist, 2<:/\so dass 4 6 1 9 0 2 zu 1 0 1 0 1 wird. Dann nimmt es das Ergebnis und prüft jedes Zahlenpaar auf Ungleichheit 2~:/\So wird 1 0 1 0 1 zu 1 1 1. Schließlich multipliziert es sie alle miteinander, um entweder eine 0 oder eine 1 zu erhalten. */An diesem Punkt könnten wir die Antwort zurückgeben, wenn es nicht zwei Dinge gäbe: Eine einzelne Ziffer gibt 1 zurück, wenn die Frage erfordert eine 0; und gleiche Zahlen werden genauso behandelt wie 'kleiner als', so dass 461900 1 anstelle von 0 zurückgibt. Schade. Weiter geht's ...

3. (1<#u) Dies prüft, ob die Anzahl der in u gespeicherten Elemente #ugrößer als 1 ist und gibt false zurück, wenn es sich nur um eine einstellige Zahl handelt.

4. (0=+/2=/\u) Dies nimmt jedes in u gespeicherte Zahlenpaar und prüft auf Gleichheit 2=/\u. Es summiert dann die Antworten und prüft, ob es 0 hat.

Die Ergebnisse der Teile 2, 3 und 4 werden dann multipliziert, um (hoffentlich) eine 1 zu ergeben, wenn die Anzahl den in der Frage angegebenen Anforderungen entspricht.

Haskell, 82 Bytes

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

Probieren Sie es 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 Zeichen

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 Zeichen

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

gleiche Methode wie meine Erlang-Antwort mit einer for-Schleife anstatt einer Rekursion.

Python 105 101 100 Zeichen

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)

Rekursive Lösung. c(r,t)prüft, ob das erste Zeichen rkleiner (t==-1)oder größer (t==1)als das zweite Zeichen ist, und ruft die entgegengesetzte Prüfung für den verkürzten String auf.

Perl / re, 139 Bytes

Tut alles , was in regex ist ein bisschen eine schlechte Idee.

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

Ich verwende Perl 5.12, denke aber, dass dies unter Perl 5.10 funktioniert. Ziemlich sicher, dass 5.8 raus ist.

für (qw (461902 708143 1010101 123 5)) {
    print "$ _ is". (/ crazy Regex geht hier /? '': 'nicht'). "undulant \ n";
}

461902 ist undulant
708143 ist undulant
1010101 ist undulant
123 ist nicht undulant
5 ist nicht undulant

GolfScript, 48 Bytes

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

In der Hoffnung, J zu schlagen, benutze ich zum ersten Mal GolfScript. Hat nicht ganz geklappt.

JavaScript, 66 65 62 60 Bytes

Nimmt Eingaben als Zeichenfolge, gibt trueundulierende Zahlen zurück, leere Zeichenfolgen (Falschzeichen) für einstellige Zahlen und falseandere.

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

Versuch es

Führen Sie das folgende Snippet aus, um 0-925 Zufallszahlen zu testen <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>

Erläuterung

Ein paar lustige kleine Tricks in diesem, also denke ich, dass es eine seltene Erklärung für eine JS-Lösung von mir verdient.

()=>

Wir beginnen einfach mit einer anonymen Funktion, die beim Aufruf die Ganzzahl als Argument verwendet.

[s,...a]

Dieses Argument wird sofort in zwei Parameter zerlegt: Es sist das erste Zeichen in der Zeichenfolge und aein Array, das die verbleibenden Zeichen enthält (z . B. "461902"wird s="4"und a=["6","1","9","0","2"]).

a+a&&

Zuerst verknüpfen wir uns amit sich selbst, wodurch beide Vorkommen in Zeichenfolgen umgewandelt werden. Wenn die Eingabe eine einstellige Zahl ist, aist sie leer und wird daher zu einer leeren Zeichenfolge. Eine leere Zeichenkette plus eine leere Zeichenkette ist immer noch eine leere Zeichenkette, und da dies in JS falsch ist, beenden wir die Verarbeitung beim logischen UND und geben unsere leere Zeichenkette aus. In allen anderen Fällen a+aist dies der Fall und wir fahren mit dem nächsten Teil der Funktion fort.

a.every(x=>)

Wir werden prüfen, ob jedes Element xin azurückkehrt, truewenn es eine Funktion durchläuft.

y=s<a

Dies bestimmt, was unser erster Vergleich sein wird ( <oder >) und dann werden wir von dort abwechseln. Wir prüfen, ob die Zeichenfolge skleiner ist als das Array a, das dabei in eine Zeichenfolge umgewandelt wird. Wenn sie skleiner ist als das erste Zeichen a, ywird dies der Fall sein trueoder falsenicht.

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

Wir erstellen einen String mit dem aktuellen Wert von sam Anfang und xam Ende. Dazwischen indexieren wir den String, "<>"indem wir ihn inkrementieren y, seinen anfänglichen booleschen Wert in eine Ganzzahl umwandeln und modulo um 2, was uns 0oder ergibt 1.

eval()

Bewerte diesen String.

s=x

Schließlich übergeben wir ein zweites Argument eval, das ignoriert wird, und setzen damit den Wert von sauf den aktuellen Wert von xfür die nächste Iteration.

PowerShell, 88

Naiv und trivial. Ich werde später Golf spielen.

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

Meine Testfälle .

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}

Sie müssen nur ein Argument übergeben. Ich könnte dies wahrscheinlich mit einer For-Schleife weiter Golf spielen.

Erlang, 137 123 118 Zeichen

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 ist neuer als diese Herausforderung, daher konkurriert dies nicht um das grüne Häkchen, aber es ist trotzdem kein Gewinner (obwohl ich mir sicher bin, dass dies tatsächlich einiges an Golfspielen kann).

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

Teste es hier.

Wie es funktioniert

Zuerst mache ich eine Zeichenkettenmanipulation (gefolgt von eval), um 5 Bytes bei doppeltem Code zu sparen:

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

Tatsächlich ist mein Code also

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

Zunächst gehe ich wie folgt mit dem seltsamen Sonderfall einer einzelnen Ziffer um. Ich kopiere die Ziffer bei Index 1und stelle sie der Nummer voran. Wir müssen 3 Fälle unterscheiden:

• Die ersten beiden Ziffern sind verschieden, wie 12...wir dann erhalten 212..., so dass der Start undulant ist, und wirkt sich nicht auf , ob die gesamte Zahl undulant.
• Die ersten beiden Ziffern sind gleich, also 11...bekommen wir 111.... Nun ist der Start nicht undulant, aber die Zahl war sowieso nicht undulant, daher hat dies auch keinen Einfluss auf das Ergebnis.
• Wenn die Zahl nur eine Ziffer enthält, ist die Ziffer am Index 1die erste Ziffer (da die Array-Indizierung von CJam am Ende eine Schleife bildet). Dies führt zu zwei identischen Ziffern, und die Zahl ist nicht undulant.

Schauen Sie sich jetzt den Code im Detail an:

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

Ich bin mir sicher, dass es eine kürzere Möglichkeit gibt, Ziffern (mit einer Länge von mehr als 1) dahingehend zu überprüfen, ob sie wellenförmig sind (insbesondere ohne Verwendung von zwei Falten), aber ich konnte sie noch nicht finden.

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

Um es auszuführen, speichere es einfach als golf.pl, öffne einen Prolog-Interpreter (zB gprolog) im selben Verzeichnis und mache dann:

consult(golf).
u(101010).

Es wird angegeben, trueob die Nummer undulant ist, ansonsten nur nein.

Mathematica, 46 Bytes

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

Beispiele (Leerzeichen sind nicht erforderlich):

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

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

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

Dann a-b * b-cist entweder x*-yoder -x*ymit xund yals positive Zahlen und das Produkt ist in beiden Fällen negativ, aber für -x*-yoder x*y(a <b <c oder a> b> c) ist das Produkt immer positiv.

Der Rest des Codes behandelt Sonderfälle: eine Ziffer, zwei Ziffern, zwei identische Ziffern.

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

Beispielnutzung:

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

Nimmt eine Zahl auf, kehrt truefür Undulant zurück und falsefür nicht. ZB f(163)kehrt zurück 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

Probieren Sie es online!