Undulante Zahlen

16

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.

leonardo
quelle
Zahleneingabe als String, Integer, Float ...?
aufgehört, gegen den Uhrzeigersinn
1
Was ist das Ziel hier? Code-Golf (kürzeste Funktion)?
Alexandru
1
@JBernardo: Ich denke, wahres oder undefiniertes Verhalten, da es ein besserer Basisfall für eine Rekursion wäre.
Joey Adams
4
Ihre Definition von undulant number stimmt nicht mit der Standarddefinition überein : mathworld.wolfram.com/UndulatingNumber.html . Ist das beabsichtigt?
Mellamokb
9
Meine Lösung könnte 16% kleiner sein, wenn der Basisfall wahr wäre (wie es meiner Meinung nach Sinn machen würde).
Eternalmatt

Antworten:

6

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.

JB
quelle
Es wird schwer sein, J in diesem Problem zu schlagen. schöne lösung!
Leonardo
@leonardo danke!
JB
6

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
Howard
quelle
6

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.

vergänglich
quelle
Zumindest kann ich mich damit trösten, dass ich eine Stunde lang die Führung hatte. :-)
Gareth
5

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

Bruno Le Floch
quelle
5

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
MtnViewMark
quelle
Ich bin so wütend, dass Sie meine 104-Zeichen-Lösung schlagen. 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.cycleEs ist ein bisschen elegant. zipWitheinmal mit comparewie du, dann zipWithnochmal mit (==)und cycle[GT,LT]oder cycle[LT,GT]als zweites arg.
Eternalmatt
Sie könnten inline schreiben, tail>>=zipWith comparewas einige Bytes verkürzen würde.
stolzer Haskeller
außerdem habe ich eine kürzere version von q:q[]=0<1;q(a:b:s)|a/=b,a/=EQ=q$b:s;q _=0>1
proud haskeller 27.12.14
eigentlich ist hier eine noch kürzere version: q s=and$all(/=EQ)s:zipWith(/=)s(tail s)
stolzer haskeller
@ proudhaskeller - keine der Versionen besteht alle Tests. Beide scheitern bei 3 (sollte falsch sein), und die erste scheitert bei vielen anderen, wie 32 und 101010101.
MtnViewMark
4

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!

boothby
quelle
Ich hatte eine Idee sum(uniq(...))^2, da sum([1,-1]) = 0und die Summen der Singletons [1] und [-1] Quadrate zu 1 zu verwenden. Leider schlägt es bei einer dreimal wiederholten Ziffer fehl; 1011101.
Stand vom
Nett. Ich sollte Salbei lernen. Übrigens habe ich gerade festgestellt, dass Backticks einen anhängen, Lwenn die Zahl in Python größer als 2 ** 32 ist und das Ergebnis beeinflusst. Passiert das auf Sage?
JBernardo
Ja, Sage macht ein paar Dinge zum Golfen gut ... zum Beispiel wird die lächerliche Startzeit damit verbracht, einen riesigen Baum von Modulen zu importieren. Die Sage Integer-Klasse kümmert sich nicht darum, Lweil Sage Python ist. 1234 -> Ganzzahl ('1234'). Sie können direkt mit Sage anfangen
boothby
4

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

quelle
3

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)
JBernardo
quelle
3

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.

DocMax
quelle
2
In JavaScript benötigt eine Funktion keinen Namen und die Frage fragt explizit nach einer Funktion. Sie können also zwei Zeichen speichern.
Ry
3

K, 41 Bytes

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

Z.B

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

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
Ricardo Tomasi
quelle
3

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.

Gareth
quelle
Netter Job, der die Führung wieder übernimmt, aber ich habe mir gerade einen Trick von dir ausgeliehen!
Ephemient
( a.i.":
Davon abgesehen
Leider muss ich diese Ungleichheitsprüfung wahrscheinlich erneut durchführen - meine Antwort schlägt jetzt für 11, 22, 33, 44 usw. fehl.
Gareth,
3

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!

Thomas Eding
quelle
Ich zähle nur 83 Zeichen in dieser Lösung. (Sind Sie vielleicht unter Windows? Schreiben Sie die Datei mit Unix-Zeilenenden, was legal für Haskell ist.)
MtnViewMark
Danke, ich habe 'wc' benutzt, um meine Charaktere auf Cygwin zu zählen. Ich zähle 82 Zeichen. Ich habe den folgenden Code verwendet, da wc ein zusätzliches Zeichen auszugeben scheint. (Vim zeigt keinen abschließenden Zeilenumbruch, aber der Notizblock ...) readFile "Undulant.hs" >>= print . length . dropWhile (== '\n') . reverse . filter (/= '\r')
Thomas Eding
c=cycle[(<),(>)]kann auf gekürzt werden c=(<):(>):c.
Laikoni
1
zipWith3($)l(show n)$tail$show nkann sein zipWith3($)l=<<tail$show nund ((>):c)kann sein tail c. Insgesamt 70 Bytes: Probieren Sie es online!
Laikoni
3

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]
Kirill
quelle
2
Gute Verwendung von xor. Sie können ziemlich viele Zeichen ausschneiden, ... for a,b in zip(t,t[1:])anstatt Bereiche zu verwenden. Außerdem brauchen Sie die Klammern nicht in all([...])- Python erstellt beim Auffinden einen Generator (... for ...), auch wenn die Klammern für einen Funktionsaufruf stehen.
Stand
Vielen Dank für Ihren Rat! Sie waren sehr wertvoll! -20 Zeichen
Kirill
Sehr schöne Lösung. Nur noch wenige Zeichen x>9 and all(i^j for i,j in zip(l,l[1:]))und entfernen if l else False.
Ante
1
Es funktioniert nicht in allen Fällen. Zwei Fälle sind problematisch: Nur 2 Ziffern (z. B. 11) und die letzten 2 Ziffern sind gleich und größer als eine zuvor (z. B. 12155). Das erste Problem ist, dass nicht getestet wird, ob x <100 ist. Der zweite Grund ist der Einbahnstraßenvergleich. Es kann repariert cmp(i,j)und stattdessen i^jgesetzt i*j<0und getestet werden and l[0]!=0. Einige weitere Charaktere: - /
Ante
1
Hmmm ... printspeichert ein Zeichen return, aber ist es legitim? Die Spezifikation fordert eine Funktion an, die "zurückgibt".
2

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]))
Keith Randall
quelle
2

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.

Scott Logan
quelle
2

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.

Ante
quelle
Nett. Sie können ein Zeichen in der ersten Zeile 0speichern, indem Sie es entfernen , und Sie können drei Zeichen in der zweiten Zeile speichern, indem Sie u=lambda x:x>9 and c(`x`,cmp(*`x`[:2])or 1)
Tnx. Ich mochte keine () von Anfang an :-)
Ante
Sie können eine weitere speichern, indem Sie schreiben x>9and.
2

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
vergänglich
quelle
2

GolfScript, 48 Bytes

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

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

vergänglich
quelle
2

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.

Zottelig
quelle
1

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 .

Joey
quelle
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}

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

Ry-
quelle
( d>=l-> d>0) und ( d<=l-> d<2) vielleicht? Ich schaue nicht genau hin, da es vielleicht dBruchteile gibt, die es verzerren könnten.
Thomas Eding
@ Trinithis: Das ist ein Kleinbuchstabe L, kein 1. Trotzdem danke!
Ry
Wo ist DejaVu Sans Mono oder Bitstream Vera Sans Mono, wenn Sie es brauchen? Vielleicht muss ich den Stackoverflow mit einem benutzerdefinierten CSS oder einem Benutzerskript anpassen ...
Thomas Eding
@trinithis: Ich stimme zu, die Schriftartauswahl ist nicht so toll. Mut ist nicht gut genug ...
Ry
1

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)).
Scott Logan
quelle
Wird dies nicht wahr sein, solange es irgendwo mindestens einen Auf- und einen Ab-Übergang gegeben hat? Wird es nicht True zurückgeben für, sagen wir 1234321?
MtnViewMark
@ MtnViewMark, ja danke, ich habe die Frage jetzt hoffentlich behoben falsch verstanden.
Scott Logan
1

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.

Martin Ender
quelle
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]).

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.

pgy
quelle
1

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

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.

Benutzer unbekannt
quelle
1

Perl, 78 Bytes

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

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
tmartin
quelle
Du kannst die if {(x>9)&any all a=#[;(1 -1;-1 1)](#)a:1_signum(-':)("I"$')($)x}gives 62 wegloggen
Skeevey
Noch nie zuvor gesehene ($)Syntax stringund die Logik ist eine nette Geste.
Tmartin
1

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!

gggg
quelle