18

Sua tarefa é escrever um programa ou função de computador que obtenha uma lista de números inteiros positivos de pelo menos o comprimento 2 e determine se eles são um "zigue-zague". Uma sequência é um ziguezague se, e somente se, os números se alternarem em maiores e menores do que o número que vem antes deles. Por exemplo e são ziguezagues, mas e não são. $[1,2,0,3,2]$ $[4,2,3,0,1]$ $[1,2,0,0,3,1]$ $[1,2,3,1]$

Para sua decisão, você deve gerar um dos dois valores consistentes diferentes para cada possibilidade (em zigue-zague e não em zigue-zague).

Os pontos de código do seu programa ou função também devem ser em zigue-zague. Isso significa que quando você pega a sequência de pontos de código, deve ser um zigue-zague.

Isso é código-golfe, então as respostas serão pontuadas em bytes, com menos bytes sendo melhores.

— Assistente de Trigo
fonte

1

Uma penalidade para cada não-ziguezague nos pontos de código pode ter sido outra abordagem, para permitir a participação de uma variedade maior de idiomas.

— ngm

5

@ngm eu discordo. A introdução de bônus / penalidades faria com que os usuários apresentassem várias respostas possíveis (por exemplo, uma curta + penalidade vs longa + sem penalidade), tornando o processo de resposta mais lento. Além disso, a quantidade de penalidade aplicada será bastante arbitrária, o que significa que o processo de pontuação não seria esse objetivo.

— JungHwan Min

2

Devemos usar pontos de código Unicode ou os pontos de código da codificação que estamos usando?

— Dennis

1

@Dennis Os pontos de código da codificação que você está usando.

— Assistente de trigo

2

@ Dennis, é claro, tecnicamente isso é verdade. No entanto, já estabelecemos que a concessão de bônus por código-golfe não é o ideal, porque prejudica o principal desafio. A penalidade neste caso seria um bônus negativo.

— JungHwan Min

7

Gelatina , 5 bytes

IṠIỊẸ

Retorna (em zigue-zague) ou (não em zigue-zague). $0$ $1$

Os pontos de código estão na página de códigos Jelly . $[73, 205, 73, 176, 174]$

Experimente online!

Como funciona

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
fonte

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

Experimente online!

Eu queria fazer a bola rolar em termos de respostas de Haskell. Ainda não vejo uma maneira de melhorar isso, mas estou convencido de que isso pode ser feito. Estou ansioso pelo que as pessoas podem fazer daqui.

— Assistente de Trigo
fonte

4

MATL , 9 bytes

dt?ZSd]pA

Experimente online! Ou verifique todos os casos de teste

Meu primeiro programa de MATL! O penúltimo pfoi adicionado para o requisito em zigue-zague.

Explicação:

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 - Restabelecer Monica
fonte

Obrigado! Sim, como mencionei na resposta, eu o adicionei apenas para o requisito em zigue-zague (já que o código em si precisa ir em zigue-zague). ]aparentemente vive entre letras maiúsculas e minúsculas; portanto, dpara ]e ]para Aambos seriam decréscimos, o que não é permitido. Portanto, pexiste principalmente para haver um incremento de ponto de código entre os dois.

— sundar - Restabelece Monica

1

Ah, eu esqueci totalmente esse requisito. Isso torna a resposta mais impressionante!

— Luis Mendo

4

Python 2 , 225 223 161 139 bytes

^{-2 bytes graças a Jakob}
^{-62 bytes graças a 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: ])])` )")

Experimente online!

Os créditos para o algoritmo acidentado vão para esta resposta

input, print, exec, defE lambdanão são acidentado então eu só fui evalpara a esquerda, que é armazenado no e
Há 2 principais maneiras de contornar a restrição, colocando "+"ou entre os pares não-esburacadas, optei para a antiga ( é mais curto para cada uso, mas seria necessário replace(' ','')resultar em mais bytes)
Como printnão é acidentado, não posso usá-lo diretamente e, como não é uma função, não posso usá-lo por dentro eval(), então tive que usar input(result)para gerar o resultado

— Cajado
fonte

Agradável. Você pode substituir ' ' * 0por ' ' [1: ].

— Jakob

Você pode usar input(text)para escrever em STDOUT.

— Dennis

4

K (ngn / k) , 23 bytes

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

Experimente online!

— ngn
fonte

Por que os espaços são necessários?

— Zacharý 04/07/19

@ Zachary o próprio código k não seria acidentado sem eles

— NGN

O que você quer dizer com isso? É apenas NGN / k que neads os espaços

— Zachary

3

@ Zacharý Este desafio é de fonte restrita e a restrição é que o código deve ser em zigue-zague.

— Erik the Outgolfer

Opa, esqueci disso também.

— Zacharý

3

Ohm v2 , 5 bytes

δyδ½Å

Experimente online!

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

Como funciona

δyδ½Å - Programa completo / Bloco de argumento único.
δy - Os sinais dos deltas da entrada 
  δ - As diferenças dos sinais. Resulta em uma sequência de 2 ou -2 para
        matrizes irregulares, como os sinais se alternam, dando -1-1 = -2 ou 1 - (- 1) = 2.
    Å - Verifique se todos os elementos produzem resultados verdadeiros quando ...
   ½ - Metade.

— Mr. Xcoder
fonte

2

Japonês `-!` , 16 14 bytes

Bem, isso não é bonito, mas estou feliz que funcione!

Saídas truepara zig-zag ou falsese não.

ä'- m'g ä'a èÍ

Tente

Os pontos de código são [228,39,45,32,109,39,103,32,228,39,97,32,232,205]e estão incluídos como teste no link acima.

Explicação

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

— Shaggy
fonte

@KamilDrakari, normalmente você estaria certo, mas, infelizmente, eles são necessários para atender aos requisitos de fonte restrita do desafio. Caso contrário, isso pode ser 10 bytes .

— Shaggy

Ah, eu não vi que isso era de fonte restrita. Meu mal

— Kamil Drakari

@KamilDrakari, não se preocupe; parece que você não era o único.

— Shaggy

1

Gelatina , 6 bytes

IṠµaIẠ

Experimente online!

Retorna 1por verdade, 0por falsidade.

Pontos de código : [73, 205, 9, 97, 73, 171]( válido )

— Erik, o Outgolfer
fonte

1

Perl 6 , 61 bytes

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

Experimente online!

Os pontos de código são:

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

E sim, esses são caracteres unicode lá. Esta é mais ou menos a minha solução original, com alguns espaços e suspensórios misturados.

— Brincadeira
fonte

1

05AB1E , 10 bytes

¥DÄ/¥(Ä2QP

Experimente online!

Explicação

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

Os pontos de código são: [165, 68, 196, 47, 165, 40, 196, 50, 81, 80]

— Emigna
fonte

1

JavaScript (ES6), 62 60 bytes

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

Experimente online!

Pontos de código:

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
fonte

2

Felizmente mapé em zigue-zague!

— Neil

0

05AB1E , 8 bytes

¥.±¥Ä2/P

Retorna 1.0para 0.0sequências em zigue-zague e para não zigue-zague.

Os pontos de código estão [164,108,176,164,195,2,109,25]na página de códigos 05AB1E .

Experimente online.

Explicação:

¥           # 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
fonte

Em um passeio acidentado

Gelatina , 5 bytes

Como funciona

Haskell , 87 bytes

MATL , 9 bytes

Python 2 , 225 223 161 139 bytes

K (ngn / k) , 23 bytes

Ohm v2 , 5 bytes

Como funciona

Japonês -! , 16 14 bytes

Explicação

Gelatina , 6 bytes

Perl 6 , 61 bytes

05AB1E , 10 bytes

JavaScript (ES6), 62 60 bytes

05AB1E , 8 bytes

Japonês `-!` , 16 14 bytes