Pour une balade cahoteuse

18

Votre tâche consiste à écrire un programme ou une fonction informatique qui prend une liste d'entiers positifs d'au moins 2 et détermine s'il s'agit d'un "zigzag". Une séquence est un zigzag si et seulement si les nombres alternent en étant plus grands et plus petits que le nombre qui les précède. Par exemple, et sont des zigzags mais et ne le sont pas.[1,2,0,3,2][ 1 , 2 , 0 , 0 , 3 , 1 ] [ 1 , 2 , 3 , 1 ][4,2,3,0,1][1,2,0,0,3,1][1,2,3,1]

Pour votre décision, vous devez sortir l'une des deux valeurs cohérentes différentes pour chaque possibilité (zigzag et non zigzag).

Les points de code de votre programme ou fonction doivent également être un zigzag lui-même. Cela signifie que lorsque vous prenez la séquence de points de code, il doit s'agir d'un zigzag.

Il s'agit de donc les réponses seront notées en octets avec moins d'octets mieux.

Post Rock Garf Hunter
la source
1
Une pénalité pour chaque non-zigzag dans les points de code aurait pu être une autre approche, pour permettre à une plus grande variété de langues de participer.
ngm
5
@ngm je ne suis pas d'accord. L'introduction de bonus / pénalités obligerait les utilisateurs à trouver plusieurs réponses possibles (par exemple, une courte + une pénalité vs une longue + aucune pénalité), ce qui rendrait le processus de réponse plus lent. De plus, le montant de la pénalité sera assez arbitraire, ce qui signifie que le processus de notation ne serait pas cet objectif.
JungHwan Min
2
Faut-il prendre des points de code Unicode ou les points de code de l'encodage que nous utilisons?
Dennis
1
@Dennis Les points de code de l'encodage que vous utilisez.
Post Rock Garf Hunter
2
@Dennis bien sûr, techniquement c'est vrai. Cependant, nous avons déjà établi que l' attribution de bonus pour le golf de code n'est pas idéale car ils nuisent au défi principal. Dans ce cas, la pénalité serait un bonus négatif.
JungHwan Min

Réponses:

7

Gelée , 5 octets

IṠIỊẸ

Renvoie (zigzag) ou 1 (pas zigzag).01

Les points de code sont dans la page de codes Jelly .[73,205,73,176,174]

Essayez-le en ligne!

Comment ça fonctionne

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
la source
4

Haskell , 87 octets

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

Essayez-le en ligne!

Je voulais faire bouger les choses en termes de réponses Haskell. Je ne vois pas encore de moyen d'améliorer cela, mais je suis convaincu que cela peut être fait. J'ai hâte de voir ce que les gens peuvent faire d'ici.

Post Rock Garf Hunter
la source
4

MATL , 9 octets

dt?ZSd]pA

Essayez-le en ligne! Ou vérifiez tous les cas de test

Mon tout premier programme MATL! L'avant-dernier a pété ajouté pour l'exigence de zigzag.

Explication:

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 - Rétablir Monica
la source
Je vous remercie! Oui, comme je l'ai mentionné dans la réponse, je l'ai ajouté uniquement pour l'exigence de zigzag (puisque le code lui-même doit aller en zigzag). ]vit apparemment entre les majuscules et les minuscules, donc dà ]et ]à Aaurait été des diminutions, ce qui n'est pas autorisé. Donc, le pest principalement là pour avoir un incrément de point de code entre les deux.
sundar
1
Oh, j'ai totalement oublié cette exigence. Cela rend la réponse plus impressionnante!
Luis Mendo
4

Python 2 , 225 223 161 139 octets

-2 octets grâce à Jakob
-62 octets grâce à 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: ])])` )")

Essayez-le en ligne!

Les crédits pour l'algorithme cahoteux vont à cette réponse

input, print, exec, defEt lambdane sont pas bosselée donc je ne suis evalparti, ce qui est stocké sur e
Il existe 2 façons de contourner la restriction, en plaçant "+"ou entre les paires non bosselées, j'ai opté pour l'ancien ( est plus courte pour chaque utilisation, mais il faudrait qu'il en replace(' ','')résulte plus d'octets.)
Comme ce printn'est pas cahoteux, je ne peux pas l'utiliser directement, et comme ce n'est pas une fonction, je ne peux pas l'utiliser à l'intérieur eval(), donc j'ai dû utiliser input(result)pour sortir le résultat

Barre
la source
Agréable. Vous pouvez remplacer ' ' * 0par ' ' [1: ].
Jakob
Vous pouvez utiliser input(text)pour écrire dans STDOUT.
Dennis
4

K (ngn / k) , 23 octets

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

Essayez-le en ligne!

ngn
la source
Pourquoi les espaces sont-ils nécessaires?
Zacharý
@ Zacharý, le code k lui-même ne serait pas cahoteux sans eux
ngn
Que veux-tu dire par là? Est-ce juste ngn / k qui vide les espaces
Zacharý
3
@ Zacharý Ce défi est de source restreinte , et la restriction est que le code doit être un zigzag.
Erik the Outgolfer le
Oups, j'ai oublié ça aussi.
Zacharý
3

Ohm v2 , 5 octets

δyδ½Å

Essayez-le en ligne!

[131,121,131,16,165]

Comment ça fonctionne

δyδ½Å - Programme complet / bloc à argument unique.
δy - Les signes des deltas de l'entrée 
  δ - Les différences des signes. Résultats dans une séquence de 2 ou -2 pour
        tableaux cahoteux, comme les signes alternent, donnant soit -1-1 = -2 ou 1 - (- 1) = 2.
    Å - Vérifiez si tous les éléments donnent des résultats véridiques lorsque ...
   ½ - Coupé en deux.
M. Xcoder
la source
2

Japt -! , 16 14 octets

Eh bien, ce n'est pas joli mais je suis juste content que ça marche!

Sorties truepour zig-zag ou falsesinon.

ä'- m'g ä'a èÍ

Essayez-le

Les points de code sont [228,39,45,32,109,39,103,32,228,39,97,32,232,205]et sont inclus comme test dans le lien ci-dessus.


Explication

                   :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.
Hirsute
la source
@KamilDrakari, normalement vous auriez raison mais, malheureusement, ils sont nécessaires pour répondre aux exigences de source restreinte du défi. Sinon, cela pourrait être de 10 octets .
Shaggy
Oh, je n'ai pas vu que c'était une source restreinte. My bad
Kamil Drakari
@KamilDrakari, ne vous inquiétez pas; on dirait que tu n'étais pas le seul.
Shaggy
1

Perl 6 , 61 octets

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

Essayez-le en ligne!

Les points de code sont:

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

Et oui, ce sont des caractères unicode là-dedans. C'est plus ou moins ma solution d'origine, avec quelques espaces et accolades mélangés.

Jo King
la source
1

05AB1E , 10 octets

¥DÄ/¥(Ä2QP

Essayez-le en ligne!

Explication

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

Les points de code sont: [165, 68, 196, 47, 165, 40, 196, 50, 81, 80]

Emigna
la source
1

JavaScript (ES6), 62 60 octets

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

Essayez-le en ligne!

Points de code:

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
la source
2
Heureusement, mapc'est en zigzag!
Neil
0

05AB1E , 8 octets

¥.±¥Ä2/P

Renvoie 1.0pour les 0.0séquences en zigzag et pour les séquences sans zigzag.

Les points de code se trouvent [164,108,176,164,195,2,109,25]dans la page de codes 05AB1E .

Essayez-le en ligne.

Explication:

¥           # 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
la source