18

Ihre Aufgabe ist es, ein Computerprogramm oder eine Funktion zu schreiben, die eine Liste positiver Ganzzahlen von mindestens Länge 2 erstellt und feststellt, ob es sich um "Zickzack" handelt. Eine Sequenz ist nur dann ein Zickzack, wenn die Zahlen abwechselnd größer und kleiner sind als die Zahl, die vor ihnen steht. Zum Beispiel sind und Zickzacke, aber und sind nicht. $[1,2,0,3,2]$ $[4,2,3,0,1]$ $[1,2,0,0,3,1]$ $[1,2,3,1]$

Für Ihre Entscheidung sollten Sie für jede Möglichkeit einen von zwei verschiedenen konsistenten Werten ausgeben (Zickzack und nicht Zickzack).

Die Code-Punkte Ihres Programms oder Ihrer Funktion müssen auch selbst ein Zick-Zack sein. Das heißt, wenn Sie die Sequenz der Codepunkte nehmen, sollte es ein Zickzack sein.

Dies ist Codegolf, daher werden die Antworten in Bytes bewertet, wobei weniger Bytes besser sind.

— Weizen-Assistent
quelle

1

Eine Strafe für jeden Nicht-Zick-Zack-Punkt in den Codepunkten könnte ein anderer Ansatz gewesen sein, um die Teilnahme einer größeren Vielfalt von Sprachen zu ermöglichen.

— ngm

5

@ngm Ich stimme nicht zu. Das Einführen von Boni / Strafen würde dazu führen, dass Benutzer mehrere mögliche Antworten finden (z. B. eine kurze Strafe + eine lange Strafe + keine Strafe), was den Antwortprozess verlangsamt. Außerdem ist die Höhe der Strafe völlig willkürlich, was bedeutet, dass der Bewertungsprozess nicht so objektiv wäre.

— JungHwan Min

2

Sollten wir Unicode-Codepunkte oder die Codepunkte der von uns verwendeten Codierung verwenden?

— Dennis

1

@Dennis Die Codepunkte der von Ihnen verwendeten Codierung.

— Weizen-Assistent

2

@Dennis natürlich, technisch stimmt das. Wir haben jedoch bereits festgestellt, dass die Vergabe von Prämien für Code-Golf nicht optimal ist, da sie die Hauptherausforderung beeinträchtigen. Eine Strafe wäre in diesem Fall ein negativer Bonus.

— JungHwan Min

7

Gelee , 5 Bytes

IṠIỊẸ

Gibt (Zickzack) oder (nicht Zickzack) zurück. $0$ $1$

Die Codepunkte sind in der Jelly-Codepage . $[73, 205, 73, 176, 174]$

Probieren Sie es online!

Wie es funktioniert

IṠIỊẸ  Main link. Argument: A (array)

I      Increments; compute the forward differences of A.
 Ṡ     Take their signs.
       A is zigzag iff the signs are alternating.
  I    Take the increments again.
       Alternating signs result in an increment of -2 or 2.
       Non-alternating signs result in an increment of -1, 0, or 1.
   Ị   Insignificant; map each increment j to (|j| ≤ 1).
    Ẹ  Any; return 0 if all results are 0, 1 in any other case.

— Dennis
quelle

4

Haskell , 87 Bytes

f(a:b:c:d)|(>)a b,b<c=f$b:c:d |(<)a b,b>c=f$b:c:d |1>0=1>12
f[a ] =1<12
f(a:b:_)= a/= b

Probieren Sie es online!

Ich wollte den Ball ins Rollen bringen, was die Antworten von Haskell angeht. Ich kann noch keinen Weg finden, dies zu verbessern, aber ich bin überzeugt, dass dies möglich ist. Ich freue mich darauf, was die Leute von hier aus tun können.

— Weizen-Assistent
quelle

4

MATL , 9 Bytes

dt?ZSd]pA

Probieren Sie es online! Oder überprüfen Sie alle Testfälle

Mein erstes MATL-Programm! Das vorletzte pwurde für die Zick-Zack-Anforderung hinzugefügt.

Erläuterung:

d    %take the difference between successive elements of input
t    %duplicate that
?    %if that is all non-zero
  ZS %take the sign of those differences (so input is all `-1`s and `1`s now)
  d  %take the difference of that (so if there are successive `1`s or `-1`s, this will have a 0)
]    %end-if
p    %take the product of topmost stack vector (will be 0 if either the original difference or 
     % the difference-of-signs contained a 0)
A    %convert positive products to 1 (since OP specifies "you should output one of two different consistent values for each possibility ")

— Sundar - Setzen Sie Monica wieder ein
quelle

Vielen Dank! Ja, wie ich in der Antwort erwähnt habe, habe ich es nur für die Zick-Zack-Anforderung hinzugefügt (da der Code selbst Zick-Zack sein muss). ]anscheinend lebt zwischen großbuchstaben und kleinbuchstaben, also dzu ]und ]zu Awäre beides dekrementiert worden, was nicht erlaubt ist. Also pist das hauptsächlich da, um ein Codepunktinkrement zwischen den beiden zu haben.

— Sundar - Reinstate Monica

1

Oh, ich habe diese Anforderung total vergessen. Das macht die Antwort eindrucksvoller!

— Luis Mendo

4

Python 2 , 225 223 161 139 Bytes

^{-2 Bytes dank Jakob}
^{-62 Bytes dank Dennis}

e={eval }.pop()
p ="i"+"n"+"p"+"u"+"t ( "
s=e(p +")")
e(p +"` a"+"l"+"l([(x<y>z)+(x>y<z)f"+"o"+"r x,y,z i"+"n zip(s,s [1: ],s [2: ])])` )")

Probieren Sie es online!

Credits für den holprigen Algorithmus gehen an diese Antwort

input, print, exec, defUnd lambdasind nicht so holprig I bekam nur evallinks, die auf gespeichert e
Es 2 wichtigsten Möglichkeiten zur Umgehung der Beschränkung sind, Anordnen "+"oder zwischen den nicht holprigen Paaren I entschied sich für die erstere ( ist für jede Verwendung kürzer, aber es müsste replace(' ','')mehr Bytes ergeben)
Da printes nicht holprig ist, kann ich es nicht direkt verwenden, und da es keine Funktion ist, kann ich es nicht im Inneren verwenden eval(), also musste ich es verwenden, input(result)um das Ergebnis auszugeben

— Stange
quelle

Nett. Sie können ersetzen ' ' * 0für ' ' [1: ].

— Jakob

Mit können Sie input(text)in STDOUT schreiben.

— Dennis

4

K (ngn / k) , 23 Bytes

{*/ 0 >1_ *':1_ -': x }

Probieren Sie es online!

— ngn
quelle

Warum werden die Räume benötigt?

— Zacharý

@ Zacharý der K-Code selbst wäre ohne sie nicht holprig

— ngn

Was meinst du damit? Ist es nur ngn / k, die die Räume

— neads

3

@ Zacharý Diese Herausforderung ist eine eingeschränkte Quelle , und die Einschränkung besteht darin, dass der Code ein Zickzack sein muss.

— Erik der Outgolfer

Hoppla, das hast du auch vergessen.

— Zacharý

3

Ohm v2 , 5 Bytes

δyδ½Å

Probieren Sie es online!

$[131,121,131,16,165]$

Wie es funktioniert

δyδ½Å - Vollständiges Programm / Block mit einem Argument.
δy - Die Vorzeichen der Deltas der Eingabe 
  δ - Die Unterschiede der Vorzeichen. Ergibt eine Folge von 2 oder -2 für
        holprige Arrays, wenn sich die Zeichen abwechseln, was entweder -1-1 = -2 oder 1 - (- 1) = 2 ergibt.
    Å - Überprüfen Sie, ob alle Elemente wahrheitsgemäße Ergebnisse liefern, wenn ...
   ½ - halbiert.

— Mr. Xcoder
quelle

2

Japt `-!` , 16 14 Bytes

Nun, das ist nicht schön, aber ich bin froh, dass es funktioniert!

Ausgänge truefür Zick-Zack oder falsewenn nicht.

ä'- m'g ä'a èÍ

Versuch es

Codepunkte sind [228,39,45,32,109,39,103,32,228,39,97,32,232,205]und als Test im obigen Link enthalten.

Erläuterung

                   :Implicit input of array
ä'-                :Consecutive differences
    m'g            :Map signs
        ä'a        :Consecutive absolute differences
             Í     :Subtract each from 2
            è      :Count the truthy (non-zero) elements
                   :Implicitly negate and output resulting boolean.

— Zottelig
quelle

@KamilDrakari, in der Regel haben Sie Recht , aber leider sind sie notwendig , die erfüllen beschränkt Source Anforderungen der Herausforderung. Andernfalls könnten dies 10 Bytes sein .

— Shaggy

Oh, ich habe nicht gesehen, dass dies eine eingeschränkte Quelle ist. Mein schlechtes

— Kamil Drakari

@KamilDrakari, mach dir keine Sorgen; es sieht so aus, als wärst du nicht der einzige.

— Shaggy

1

Gelee , 6 Bytes

IṠµaIẠ

Probieren Sie es online!

1Kehrt zurück für Wahres, 0für Falsches.

Codepunkte : [73, 205, 9, 97, 73, 171]( gültig )

— Erik der Outgolfer
quelle

1

Perl 6 , 61 Bytes

{ [*] ($_[{1…*} ] Z<@$_)Z+^ ($_[{1…*} ] Z>@$_[{2…*} ])}

Probieren Sie es online!

Die Codepunkte sind:

(123 32 91 42 93 32 40 36 95 91 123 49 8230 42 125 32 93 32 90 60 64 36 95 41 90 43 94 32 40 36 95 91 123 49 8230 42 125 32 93 32 90 62 64 36 95 91 123 50 8230 42 125 32 93 41 125)

Und ja, das sind Unicode-Zeichen. Dies ist mehr oder weniger meine ursprüngliche Lösung, mit ein paar Leerzeichen und geschweiften Klammern.

— Scherzen
quelle

1

05AB1E , 10 Bytes

¥DÄ/¥(Ä2QP

Probieren Sie es online!

Erläuterung

¥           # calculate deltas of input
 DÄ/        # divide each by its absolute value
    ¥       # calculate deltas
     (      # negate each
      Ä     # absolute value of each
       2Q   # equals 2
         P  # product

Codepunkte sind: [165, 68, 196, 47, 165, 40, 196, 50, 81, 80]

— Emigna
quelle

1

JavaScript (ES6), 62 - 60 Byte

a=> a.map(n=> e&=!~(p | q)| q <(q=p)^ p <(p=n), e=p=q=~ 0)|e

Probieren Sie es online!

Code Punkte:

61 3d 3e 20 61 2e 6d 61 70 28 6e 3d 3e 20 65 26
3d 21 7e 28 70 20 7c 20 71 29 7c 20 71 20 3c 28
71 3d 70 29 5e 20 70 20 3c 28 70 3d 6e 29 2c 20
65 3d 70 3d 71 3d 7e 20 30 29 7c

— Arnauld
quelle

2

Zum Glück mapist Zickzack!

— Neil

0

05AB1E , 8 Bytes

¥.±¥Ä2/P

Gibt 1.0für zickzackförmige und 0.0nicht zickzackförmige Sequenzen zurück.

Die Codepunkte befinden sich [164,108,176,164,195,2,109,25]auf der Codepage 05AB1E .

Probieren Sie es online aus.

Erläuterung:

¥           # Take the deltas of the (implicit) input-list
            #  i.e. [1,2,0,3,2,3] → [1,-2,3,-1,1]
 .±         # Calculate the sign for each of them (-1 if a<0; 0 if 0; 1 if a>0)
            #  i.e. [1,-2,3,-1,1] → [1,-1,1,-1,1]
   ¥        # Calculate the deltas of those
            #  i.e. [1,-1,1,-1,1] → [-2,2,-2,2]
    Ä       # Take the absolute value of each
            #  i.e. [-2,2,-2,2] → [2,2,2,2]
     2/     # Divide them by 2
            #  i.e. [2,2,2,2] → [1.0,1.0,1.0,1.0]
            # (`;` {halve} would have been shorter, but doesn't comply to the challenge)
       P    # Take the product of the list resulting in either 1.0 or 0.0
            #  i.e. [1.0,1.0,1.0,1.0] → 1.0

— Kevin Cruijssen
quelle

Auf zu einer holprigen Fahrt

Gelee , 5 Bytes

Wie es funktioniert

Haskell , 87 Bytes

MATL , 9 Bytes

Python 2 , 225 223 161 139 Bytes

K (ngn / k) , 23 Bytes

Ohm v2 , 5 Bytes

Wie es funktioniert

Japt -! , 16 14 Bytes

Erläuterung

Gelee , 6 Bytes

Perl 6 , 61 Bytes

05AB1E , 10 Bytes

JavaScript (ES6), 62 - 60 Byte

05AB1E , 8 Bytes

Japt `-!` , 16 14 Bytes