Existe um solavanco?

39

Dada uma lista de números inteiros positivos, determine se existe um elemento que é maior que seus dois vizinhos ou menor que seus dois vizinhos (um "bump"). Para ficar claro, um solavanco nunca pode ser o primeiro ou o último item da lista, porque eles têm apenas um vizinho.

Seu programa deve gerar um dos dois valores consistentes, cada um correspondente a uma lista sem bumps ou a uma lista com bumps. Quais são os valores não são importantes, você pode escolhê-los.

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

Casos de teste

[] -> False
[1] -> False
[1,2] -> False
[1,2,1] -> True
[1,2,2] -> False
[1,2,3] -> False
[1,2,2,1] -> False
[1,2,2,3] -> False
[1,2,1,2] -> True
[1,3,2] -> True
[3,1,2] -> True
[2,2,2] -> False

code-golf number array-manipulation decision-problem

— Assistente de Trigo
fonte

5

Solicitação de Caso de Teste: Números diferentes de 0-1-2-3, também negativos são permitidos / não permitidos?

— 96018 Octopus Magic Urn

Caso de teste sugerido: [1,3,3](garante que as respostas utilizando o algoritmo de Dennis levam o sinal dos incrementos em vez de apenas usando-se os incrementos)

— ETHproductions

1

@ETHproductions Isso já não está coberto [1,2,2]? Ou eu estou esquecendo de alguma coisa?

— Nic Hartley

2

@ NicHartley, os deltas de [1,2,2]são os mesmos que os sinais desses deltas, mas esse não é o caso [1,3,3].

— Salsicha

Respostas:

15

Geléia , 5 bytes

IṠIỊẠ

Retorna 0 se houver um aumento, 1 se não houver.

Experimente online!

Como funciona

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

I      Increments; take all forward differences of A.
 Ṡ     Take the signs.
       The signs indicate whether the array is increasing (1), decreasing (-1), or
       constant at the corresponding point. A 1 followed by a -1 indicates a local
       maximum, a -1 followed by a 1 a local minimum.
  I    Increments; take the forward differences again.
       Note that 1 - (-1) = 2 and (-1) - 1 = -2. All other seven combinations of
       signs map to -1, 0, or 1.
   Ị   Insignificant; map each difference d to (-1 ≤ d ≤ 1).
    Ạ  All; return 1 if all differences are insignificant, 0 if not.

— Dennis
fonte

1

O que é "Incrementos?". O que está sendo incrementado e o que isso faz?

— Assistente de trigo

1

@WheatWizard Eu acho que isso é equivalente ao comando deltas (¥) do 05AB1E: uma matriz [n0, n1, n2, n3] é exibida e a matriz [n1-n0, n2-n1, n3-n2] é pressionada.

— Kaldo

10

JavaScript (ES6), 38 bytes

Retorna um booleano.

a=>a.some(x=n=>x*(x=a<n|-(a>(a=n)))<0)

Casos de teste

Mostrar snippet de código

let f =

a=>a.some(x=n=>x*(x=a<n|-(a>(a=n)))<0)

console.log(f([]))              // False
console.log(f([1]))             // False
console.log(f([1,2]))           // False
console.log(f([1,2,1]))         // True
console.log(f([1,2,2]))         // False
console.log(f([1,2,3]))         // False
console.log(f([1,2,2,1]))       // False
console.log(f([1,2,2,3]))       // False
console.log(f([1,2,1,2]))       // True
console.log(f([1,3,2]))         // True
console.log(f([2,0,1]))         // True
console.log(f([2,2,2]))         // False
console.log(f([-4,100000,89]))  // True

Expandir snippet

Quão?

Usamos a para armazenar o valor anterior de n . Definimos x como 1 se a <n , -1 se a> n ou 0 se a = n . E testar se old_x * x <0 , o que só é possível se ( old_x = 1 e x = -1 ) ou ( old_x = -1 e x = 1 ).

Como x é inicializado para a função de retorno de chamada anônima de some () , ele é coagido ao NaN durante a primeira iteração, o que torna o teste falso.

— Arnauld
fonte

Isso será lançado no modo estrito.

— Aluan Haddad

2

@AluanHaddad Bem, 99% do código JS JS jogado no modo estrito apenas por causa de variáveis não declaradas. PPCG e codereview não se misturam bem. : P

— Arnauld 15/02

Isso é justo, não gosto muito de golfe.

— Aluan Haddad

4

Então por comentário sobre ele lol

— Mark C.

8

Haskell , 42 bytes

any(<0).f(*).f(-)
f a b=zipWith a b$tail b

Experimente online!

Explicação

Primeiro, temos a função fque pega uma função binária e uma lista e aplica a função binária a todos os pares adjacentes da lista.

Então nossa função principal se aplica f(-)à lista de entradas. Isso calcula a lista de diferenças. Em seguida, aplicamos f(*)à lista para multiplicar todos os pares adjacentes. Por fim, perguntamos se algum par é menor que zero.

Um número na lista final só pode ser negativo se for o produto de um número negativo e positivo da lista de diferenças. Portanto, para produzir uma entrada negativa (e depois retornar true), a lista original deve mudar de crescente para decrescente ou vice-versa, ou seja, deve ter um bump.

— Assistente de Trigo
fonte

Ótima maneira de lidar com a lista vazia!

— Laikoni

6

Python 2 , 43 bytes

f=lambda x,y,z,*t:0>(y-x)*(z-y)or f(y,z,*t)

Retorna True se houver um erro, erros se não houver. ( permitido por padrão )

Experimente online!

— Dennis
fonte

5

Oitava com Pacote de Imagens, 34 32 bytes

2 bytes salvos graças a @StewieGriffin !

@(x)0||prod(im2col(diff(x),2))<0

Experimente online!

Explicação

Calcula diferenças consecutivas, organiza-as em blocos deslizantes de comprimento 2, obtém o produto de cada bloco e testa se esse produto é negativo.

— Luis Mendo
fonte

0||prod(...)economiza 2 bytes. Você também pode pular toda aany peça e usar a definição padrão de verdade / falsidade para salvar 5 bytes .

— Stewie Griffin

Darn, poupando 5 bytes vai fazer sua solução mais curta do que a minha :( uso agradável do pacote de imagem que eu não sabia que estava em TIO..

— Stewie Griffin

1

@StewieGriffin Como o desafio exige dois valores consistentes, não consigo remover any. Obrigado pela 0||ideia!

— Luis Mendo

4

R, 48 bytes

function(x)any(apply(embed(diff(x),2),1,prod)<0)

Experimente online!

Como funciona passo a passo usando c (1,4,1,4) como exemplo:

> x=c(1,4,1,4)
> diff(x)
[1]  3 -3  3
> embed(diff(x),2)
     [,1] [,2]
[1,]   -3    3
[2,]    3   -3
> apply(embed(diff(x),2),1,prod)
[1] -9 -9
> any(apply(embed(diff(x),2),1,prod)<0)
[1] TRUE

Como bônus, aqui está uma solução de tamanho e conceito semelhante usando o pacote zoo:

function(x)any(zoo::rollapply(diff(x),2,prod)<0)

— plannapus
fonte

1

arrumado! Nota para si mesmo: lembre-se de que embedexiste. É muito ruim que rowProdse colProdsnão existe como aliases em R.

— Giuseppe

1

@Giuseppe de desespero eu realmente verificado se eles existiram :) mas na verdade apenas rowSumse rowMeans...

— plannapus

1

bem, pelo menos olhando os documentos, .colSumsremodelará a entrada em uma matriz com base em entradas adicionais que provavelmente têm um aplicativo de golfe em algum lugar .... agora só preciso encontrar uma!

— Giuseppe

@Guiseppe: Dê uma olhada nas funções do matrixStatspacote.

— Michael M

@ MichaelM Infelizmente, devido ao tamanho do nome do pacote, ele não o torna competitivo (57 bytes:) function(x)any(matrixStats::colProds(embed(diff(x),2)))<0. Mas, para algo que não seja código de golfe, este pacote é realmente um tesouro.

— plannapus

4

Haskell , 33 bytes

f(p:r@(c:n:_))=(c-p)*(c-n)>0||f r

Experimente online!

True se houver um solavanco, erros se não houver.

— totalmente humano
fonte

l`zip3`tail l$drop 2lé apenas um cabelo mais curto. Gostaria de saber se a correspondência de padrões é de alguma forma ainda mais curta?

— 21418 Lynn

3

Perl 6 , 39 bytes

{so~(.[1..*]Zcmp$_)~~/'re L'|'s M'/}

Experimente online!

$_é o argumento da lista para essa função anônima. .[1..*]é a mesma lista, mas com o primeiro elemento descartado. Zcmpfecha as duas listas junto com o cmpoperador, resultando em uma lista de Ordervalores. Por exemplo, para uma lista de entrada, 1, 2, 2, 2, 1isso resultaria na lista More, Same, Same, Less.

Agora só precisamos saber se essa lista contém dois elementos adjacentes More, Lessou Less, More. O truque que usei é converter a lista em uma string delimitada por espaço ~e testar se ela contém substring re Lou s M. (O primeiro não pode ser apenas e Lporque Sametambém termina com um "e".)

O operador de correspondência inteligente retorna um Matchobjeto (se a correspondência for bem-sucedida) ou Nil(se não foi o caso); portanto, soconverte o que quer que seja em um valor booleano.

— Sean
fonte

3

Wolfram Language (Mathematica) , 40 bytes

MatchQ[{___,x_,y_,z_,___}/;x<y>z||x>y<z]

Experimente online!

— alefalpha
fonte

3

Rubi , 55 46 bytes

->a{a.each_cons(3).any?{|x,y,z|(y-x)*(y-z)>0}}

Experimente online!

Um lambda aceitando uma matriz e retornando booleano.

-9 bytes: Substitua (x<y&&y>z)||(x>y&&y<z)por (y-x)*(y-z)>0(graças ao GolfWolf )

->a{
  a.each_cons(3)              # Take each consecutive triplet
    .any?{ |x,y,z|            # Destructure to x, y, z
      (y-x)*(y-z) > 0         # Check if y is a bump
    }
}

— benj2240
fonte

1

Eu acho que você pode usar em |vez de ||, economizando 1 byte.

— Yytsi 15/02

46 bytes

— Cristian Lupascu

Economize 1 byte com '0 <(yx) * y- = z'

— GB

3

PostgreSQL 173 bytes

SELECT DISTINCT ON(a)a,x>j and x>k OR x<least(j,k)FROM(SELECT a,x,lag(x,1,x)OVER(w)j,lead(x,1,x)OVER(w)k FROM d WINDOW w AS(PARTITION BY rn ORDER BY xn))d ORDER BY 1,2 DESC;
     a     | c 
-----------+---
 {1}       | f
 {1,2}     | f
 {1,2,1}   | t
 {1,2,1,2} | t
 {1,2,2}   | f
 {1,2,2,1} | f
 {1,2,2,3} | f
 {1,2,3}   | f
 {1,3,2}   | t
 {2,2,2}   | f
 {3,1,2}   | t
(11 rows)

— Evan Carroll
fonte

Olá e bem-vindo ao site. Não estou familiarizado com o PostgreSQL, mas você pode reduzir a quantidade de espaço em branco que usa. Em geral, a maioria dos idiomas não exige a maioria dos tipos de espaçamento usados.

— Assistente de trigo

@WheatWizard são os dados de amostra no banco de dados, são irrelevantes.

— Evan Carroll

Qual é o seu código então? Não permitimos que a entrada seja inserida diretamente no código, e não na entrada. Se for esse o caso aqui, você deve reescrevê-lo para que ele receba informações através de um método padrão .

— Assistente de trigo

@WheatWizard a partir do link que você forneceu, codegolf.meta.stackexchange.com/a/5341/23085

— Evan Carroll

1

Ok, se esse é o formato de entrada que você está usando, tudo bem. Boa sorte no golfe aqui, é bom ver pessoas jogando golfe em idiomas menos usados.

— Assistente de trigo

3

Java 8, 108 104 101 86 84 79 72 bytes

a->{int i=a.length,p=0;for(;i-->1;)i|=p*(p=a[i]-a[i-1])>>-1;return-i>1;}

-2 bytes graças a @ OlivierGrégoire .
-13 bytes graças a @Nevay .

Experimente online.

— Kevin Cruijssen
fonte

1

84 bytes . Alterei a ordem da iteração (descendo), troquei os dois operandos de multiplicação e, em seguida, pude remover um supérfluo -1.

— Olivier Grégoire

1

79 bytes: a->{int i=a.length;for(;i-->2;)i|=(a[i]-a[--i])*(a[i]-a[i-1])>>-1;return-~i|3;}(retorna -1para casos 3verdadeiros , para casos de falsey) - ou, se estiver usando a presença / ausência de uma exceção como valor de retorno 55 bytes:a->{for(int i=0;++i>0;)i|=(a[i-1]-a[i])*(a[i]-a[i+1]);}

— Nevay 18/02/19

1

72 bytes:a->{int i=a.length,p=0;for(;i-->1;)i|=p*(p=a[i]-a[i-1])>>-1;return-i>1;}

— Nevay

3

R , 58 56 bytes

function(x)any(abs(diff(sign(diff(c(NA,x)))))>1,na.rm=T)

Experimente online!

Economizou 2 bytes graças a Giuseppe

— NofP
fonte

3

Você pode se livrar dos aparelhos {}por -2 bytes.

— Giuseppe

Além disso, eu acho que você pode porta de Stewie Griffin abordagem para 42 bytes

— Giuseppe

@ Giuseppe, acho que Stewie portou meu método, com a diferença de que o meu pode lidar adequadamente com o vetor vazio, conforme listado nos casos de teste. O Matlab é um pouco mais branda com vetores vazios em comparação com o R.

— NofP 18/02/19

c()é NULLque não é o mesmo que o vetor vazio de números inteiros, integer(0)enquanto no MATLAB []é um doublepor padrão, mas se você deseja mantê-lo dessa maneira, isso é perfeitamente razoável.

— Giuseppe

3

J , 16 15 bytes

-1 byte graças a FrownyFrog

1 e.0>2*/\2-/\]

Experimente online!

Original: 16 bytes

0>[:<./2*/\2-/\]

2-/\] - diferenças de cada item adjacente

2*/\ - produtos de cada item adjacente

[:<./ - o mínimo

0> - é negativo?

Experimente online!

— Galen Ivanov
fonte

Olá ! Não foi possível encurtar para este formulário explícito mais simples 0> <./2 * / \ 2 - / \ (13 bytes)?

— Mathias Dolidon

@Mathias Dolidon Isso funciona no intérprete, mas aqui no PPCG é comum fornecer uma função (verbo J) se houver alguma entrada. Se o verbo é tácito, não contamos os f=.bytes de atribuição . Por favor, tenha em mente que eu sou relativamente novo usuário :)

— Galen Ivanov

Eu também, e você esclareceu a regra para mim. Obrigado ! :)

— Mathias Dolidon

1

1 e.0>2*/\2-/\]

— precisa saber é o seguinte

@ FrownyFrog Obrigado! Parece que eu raramente uso e. :)

— Galen Ivanov

2

Japt , 11 bytes

-5 bytes graças a @ETHproductions

ä- mÌäa d>1

Experimente online! |Casos de teste

Isso usa o algoritmo de Dennis

— Oliver
fonte

2

Japonês , 9 bytes

ä- ä* d<0

Experimente online!

Um mashup da resposta de Oliver com a abordagem usada por várias outras respostas.

— ETHproductions
fonte

2

Anexo , 39 bytes

Any&:&{_*~?Sum[__]}@Slices&2@Sign@Delta

Experimente online!

Muito feliz com o resultado.

Explicação

Esta é uma composição de quatro funções:

Delta
Sign
Slices&2
Any&:&{_*~?Sum[__]}

Deltaobtém as diferenças entre os elementos. =

Então, Signé aplicada a cada diferença, dando uma série de 1s, 0s, e-1 s. =

Então, Slices&2 fornece todas as fatias de comprimento dois da matriz, fornecendo todos os pares de diferenças.

Finalmente, Any&:&{_*~?Sum[__]}é equivalente a, para entrada x:

Any[&{_*~?Sum[__]}, x]
Any[[el] -> { el[0] and not (el[0] + el[1] = 0) }, x]

Ele procura por elementos que somam zero, mas não são zero. Se qualquer par de elementos existir, haverá um aumento.

— Conor O'Brien
fonte

2

MATL , 8 bytes

dZSd|1>a

Experimente online!

— Stewie Griffin
fonte

2

Casca , 7 bytes

V<0Ẋ*Ẋ-

Experimente online!

Explicação

V<0Ẋ*Ẋ-  Implicit input, say [2,5,5,1,4,5,3]
     Ẋ-  Consecutive differences: [3,0,-4,3,1,-2]
   Ẋ*    Consecutive products: [0,0,-12,3,-2]
V<0      Is any of them negative? Return 1-based index: 3

— Zgarb
fonte

2

Oitava , 33 bytes

@(x)0||abs(diff(sign(diff(x))))>1

Experimente online!

Explicação:

@(x)                           % Anonymous function taking x as input
                  diff(x)       % Takes the difference between consecutive elements
             sign(diff(x))      % The sign of the differences
        diff(sign(diff(x)))     % The difference between the signs
    abs(diff(sign(diff(x)))>1   % Check if the absolute value is 2
@(x)abs(diff(sign(diff(x)))>1   % Output as matrices that are treated truthy or falsy

— Stewie Griffin
fonte

2

Braquilog , 10 bytes

s₃.¬≤₁∧¬≥₁

Experimente online!

Sucede ( true.) se houver um solavanco e falha (false. ) se não houver um solavanco.

Explicação

Isso já é bastante legível:

s₃.           There is a substring of the input…
  .¬≤₁        …which is not non-decreasing…
      ∧       …and…
       ¬≥₁    …which is not non-increasing

— Fatalizar
fonte

2

05AB1E , 7 bytes

¥ü‚P0‹Z

Experimente online!

Explicação

¥         # calculate delta's
 ü‚       # pair each element with the next element
   P      # product of each pair
    0‹    # check each if less than 0
      Z   # max

— Emigna
fonte

Não havia uma alternativa de 1 byte 0‹que basicamente verifica o número em busca de um sinal negativo?

— Urna de polvo mágico

@MagicOctopusUrn: dusado para verificar se o topo da pilha continha apenas [0-9], que é o oposto do que queremos aqui. Mas agora é mais inteligente e negativo / flutuadores também são contados como números.

— Emigna

Ahhhh ... podia jurar ter avisto o negativesinal e retornado verdadeiro ou algo assim ... Mas acho que você está certo, estou lembrando do seu dtruque.

— Urna Mágica de Polvo

2

Braquilog , 10 bytes

s₃s₂ᶠ-ᵐ×<0

Experimente online!

Não é tão elegante e elegante quanto a resposta de 10 bytes existente do @ Fatalize, mas funciona!

s₃   % There exists a substring of three elements [I,J,K] in the array such that

s₂ᶠ  % When it's split into pairs [[I,J],[J,K]]

-ᵐ   % And each difference is taken [I-J, J-K]

×    % And those differences are multiplied (I-J)*(J-K)
     % (At a bump, one of those will be negative and the other positive. 
     % At other places, both differences will be positive, or both negative, 
     %  or one of them 0 - ultimately resulting in a non-negative product.)

<0   % The product is negative

— sundar - Restabelecer Monica
fonte

1

Casca , 9 bytes

▼mεẊ-Ẋo±-

Experimente online!

Usa o algoritmo de Dennis.

— Erik, o Outgolfer
fonte

1

Perl 5 , 54 + 2 ( `-pa`) = 56 bytes

map$\|=$F[$_-1]!=(sort{$a-$b}@F[$_-2..$_])[1],2..$#F}{

Experimente online!

— Xcali
fonte

1

Python 2 , 60 bytes

lambda l:any(p>c<n or p<c>n for p,c,n in zip(l,l[1:],l[2:]))

Experimente online!

Praticamente a mesma coisa, mas pensei que seria mais curto ...

Python 2 , 63 bytes

f=lambda l:l[3:]and(l[0]>l[1]<l[2]or l[0]<l[1]>l[2]or f(l[1:]))

Experimente online!

— totalmente humano
fonte

1

58 bytes usando multiplicação

— Shieru Asakoto 15/02

1

Pyt , 11 7 bytes

₋ʁ*0<Ʃ±

Saídas 1 se houver um aumento, 0 caso contrário

Experimente online!

Resposta do Haskell do Assistente do Porto de Trigo

Maneira antiga (11 bytes):

₋±₋Å1≤ĐŁ↔Ʃ=

Experimente online!

Retorna False se houver um aumento, True caso contrário

Resposta da geléia do Porto de Dennis

— mudkip201
fonte

1

Wolfram Language (Mathematica) , 37 36 bytes

FreeQ[(d=Differences)@Sign@d@#,-2|2]&

Fornece o oposto das respostas do caso de teste (Falso e Verdadeiro invertidos). Anexar um! para mudar para o formato normal.

OU

Abs@(d=Differences)@Sign@d@#~FreeQ~2&

Saída também invertida, então substitua FreeQ por MatchQpara a forma normal.

Explicação: Pegue o sinal das diferenças da sequência. Se a sequência resultante inclui {1, -1} ou {-1,1}, há um aumento. O valor absoluto das diferenças de {1, -1} ou {-1,1} é 2 em ambos os casos.

Raspe outro byte ao quadrado da lista final em vez de pegar o valor absoluto:

FreeQ[(d=Differences)@Sign@d@#^2,4]&

Experimente online!

— Kelly Lowder
fonte

1

Perl, 35 bytes

Inclui +3para-p

bump.pl:

#!/usr/bin/perl -p
s%\S+ %$a*1*($a=$&-$')%eg;$_=/-/

Correr como:

bump.pl <<< "3 1 2"

— Ton Hospel
fonte

1

Julia 0.6 , 57 56 bytes

l->any(p>c<n||p<c>n for(p,c,n)=zip(l,l[2:end],l[3:end]))

Basicamente, apenas a resposta python totalmente humana. -1 byte do usuário71546

Experimente online!

Julia 0.6 , 39 bytes

f(x,y,z,a...)=x>y<z||x<y>z||f(y,z,a...)

Estilo de recursão Lispy, também conhecido como resposta python de Dennis. Retorna truequando existe um bump; caso contrário, gera um erro. Talvez deva ter 42 bytes, já que você precisa dividi-lo ao chamar. Por exemplo, para a=[1,2,1]você ligar como f(a...). f(a)=f(a...)removeria essa necessidade, mas é mais longa. Preciso melhorar uma recursão e não gosto muito de escrever código que gera um erro.

Experimente online!

— gggg
fonte

1

parece que o espaço depois fornão é necessário;)

— Shieru Asakoto

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.

Licensed under cc by-sa 3.0 with attribution required.