O built-in proibido


52

Nas brechas padrão , é proibido o seguinte :

Alegando que sua resposta está escrita em "MyOwnLanguage", onde o comando xsignifica "leia uma sequência de números, divida-os em grupos de três e imprima os últimos números desses grupos em que o segundo número é menor que o primeiro"

Aqui, vamos fazer exatamente a mesma coisa.

Tarefa

Dada uma sequência de números inteiros positivos, cujo comprimento é divisível por 3, divida-os em grupos de três e imprima os últimos números dos grupos em que o segundo número é menor que o primeiro.

Casos de teste

Input               Output
[]                  []
[1,2,3,4,5,6,7,8,9] []
[2,1,3,5,4,6,8,7,9] [3,6,9]
[3,1,4,1,5,9,2,6,5] [4]
[100,99,123]        [123]
[123,123,456]       []
[456,123,789]       [789]

Pontuação

Isso é . A resposta mais curta em bytes vence.

As brechas padrão se aplicam, portanto, lembre-se de não ter um comando interno xque execute essa tarefa.


31
Hmmm ... Agora estou realmente tentado a criar MyOwnLanguagee adicionar o xcomando ...: P
DJMcMayhem

6
* lembre-se de não ter um built-in *‽ Bem, se já o temos, podemos usá-lo, não?
Adám

2
@ Adám De acordo com as brechas padrão, você não pode ter um idioma que contenha o built-in xque executa especificamente essa função.
Leaky Nun

34
@LeakyNun Sim, você pode, você simplesmente não consegue criar essa linguagem por causa do desafio. Se o seu idioma antecede o desafio, é aceitável.
Adám

9
Se eu ligar para o builtin p, posso usá-lo?
Mindwin

Respostas:


14

Oitava, 32 bytes

@(L)L(x=3:3:end)(diff(L)(x-2)<0)

Experimente online!

ou

Verifique os casos de teste!

L3 = L(3:3:end)  %extract last elements of groups
d= diff(L)       % first difference of the list
y=d(1:3:end)     %extract first elements of each subgroup of the difference
idx = y<0        %check for negative numbers  
result = L3(idx)

13

Geléia , 9 8 bytes

>Ḋm3T×3ị

Experimente online!

Como funciona

>Ḋm3T×3ị  Main link. Argument: A (array)

 Ḋ        Dequeue; yield A without its first element.
>         Compare the elements of A with the elements of the result.
  m3      Select each third element, starting with the first.
    T     Truth; get all indices of truthy elements.
     ×3   Multiply those indices by 3.
       ị  Unindex; retrieve the elements at the redulting indices.

12

Haskell, 30 29 bytes

x(a:b:c:l)=[c|b<a]++x l
x d=d

Minha primeira tentativa de jogar golfe em Haskell, talvez eu tenha perdido uma ou duas otimizações

-1 byte graças a @JulianWolf


4
Boa resposta! Consulte codegolf.stackexchange.com/a/60884/66904 para obter uma dica relevante; em particular, trocando as duas definições e escrever o segundo (agora pela primeira vez), como x d=dvocê pode economizar um byte
Julian Lobo

Esperto! Eu consultei a resposta de antemão, mas deve ter perdido a parte em que a definição reutilizado a variável

11

Mathematica, 37 bytes

Supondo que isso satisfaça as especificações, a ngenisis recebe crédito por essa abordagem, levando a uma economia de 1 byte!

BlockMap[If[#>#2,Print@#3]&@@#&,#,3]&

Função pura. BlockMap[...,#,3]&divide a lista de entrada em sub-listas de tamanho 3 e em seguida opera em cada sublista com a função If[#>#2,Print@#3]&@@#&. O resultado é que cada último número qualificado é impresso. A função também retorna um valor (ou seja, uma lista de Nullum terceiro, contanto que a lista de entrada), que parece ser um comportamento permitido.

Mathematica, 42 38 bytes

Agradecemos a Martin Ender por economizar 4 bytes!

Cases[#~Partition~3,{a__,b_}/;a>0:>b]&

Função pura. #~Partition~3faz o que você pensa. Cases[X,P:>Q]seleciona todos os elementos da Xcorrespondência do padrão Pe retorna o resultado da regra de transformação :>Qaplicada a cada instância. Aqui, o padrão a ser correspondido é {a__,b_}/;a>0: b_corresponderá ao último elemento da lista e a a__todos os outros elementos (nesse caso, os dois primeiros); ligue para eles ye zpor enquanto. O sneaky a>0então se expande para y>z>0, que é o teste que queremos aplicar (válido porque a especificação diz que tudo será um número inteiro positivo). E a regra de transformação é :>b, que simplesmente substitui cada triplo ordenado correspondente pelo seu último elemento.

Submissão original:

Last/@Select[#~Partition~3,#.{1,-1,0}>0&]&

Função pura; uma implementação simples, além da #.{1,-1,0}que calcula a diferença entre o primeiro e o segundo elementos de cada sub-lista de 3 elementos.


3
O produto escalar é limpo, mas #>#2&@@#&é mais curto. Mas no geral é ainda mais curto para usar Casesem vez de Select:Cases[#~Partition~3,{a__,b_}/;a>0:>b]&
Martin Ender

a>0:>tem dois tipos de magia nele!
Greg Martin

BlockMapé tentador aqui.
Ngenisis

BlockMap[If[#>#2,#3,Nothing]&@@#&,#,3]&funciona e tem apenas 39 bytes ... podemos salvar alguns bytes?
Greg Martin

11
BlockMap[If[#>#2,Print@#3]&@@#&,#,3]&indiscutivelmente satisfaz a especificação
ngenisis

8

Pitão, 10 bytes

eMf>FPTcQ3

Suíte de teste

eMf>FPTcQ3
       cQ3    Chop the input into groups of size 3
  f           Filter on
     PT       All but the last element
   >F         Apply the greater than function
eM            Map to the last element


5

Braquilog (2), 14 bytes

~c{Ṫ}ᵐ{k>₁&t}ˢ

Experimente online!

Brachylog, ao contrário, luta com esse tipo de problema. Observe que este programa tem uma complexidade computacional horrível, pois força bruta que divide a entrada em grupos de 3 (não tendo nenhuma "divisão em grupos" incorporada); corre rapidamente com quatro grupos, mas muito lentamente com cinco.

Explicação

~c{Ṫ}ᵐ{k>₁&t}ˢ
~c              Split into groups
  { }ᵐ          such that each group
   Ṫ            has three elements
      {     }ˢ  then on each element, skipping that element on error:
       k          with the list minus its last element
        >₁        assert that it's strictly decreasing
          &       and with the original list
           t      keep only its last element

Pode valer a pena mencionar que l÷₃;?ḍ₍é uma alternativa mais rápida.
Freira vazando

Eu tive isso em uma tentativa anterior (usando /não ÷; eles são equivalentes aqui), mas é um byte mais longo, então eu o descartei enquanto jogava golfe.

4

J , 14 bytes

_3&(>`[/\#]/\)

Isso avalia um verbo monádico. Experimente online!

Explicação

_3&(>`[/\#]/\)  Input is y.
_3&(    \    )  For each non-overlapping 3-element chunk of y,
    >`[/        check if first element is greater than second.
                Call the resulting array x.
_3&(        \)  For each non-overlapping 3-element chunk of y,
          ]/    take the last element.
         #      Keep those where the corresponding element of x is 1.

4

Alice , 12 11 bytes

Agradecemos a Leo por economizar 1 byte.

I.h%I-rI~$O

Experimente online!

Usa os pontos de código de uma string como lista de entrada e gera o caractere correspondente às saídas que devem ser mantidas.

Explicação

I      Read x. Pushes -1 on EOF.
.h%    Compute x%(x+1). This terminates the program due to division by zero at EOF,
       but does nothing for non-negative x.
I      Read y.
-      Compute x-y. We only want to output z is this is positive.
r      Range. Pushes 0 1 ... n for positive n, and -n ... 1 0 for negative n
       (and simply 0 for n = 0). So this results in a positive number on top
       of the stack iff x-y is positive.
I      Read z.
~      Swap it with x-y > 0.
$O     Output z iff x-y > 0.
       Then the IP wraps to the beginning of the program to process the next triplet.

Você pode jogar um byte usando em rvez de ex. TIO
Leo

@ Leo que é brilhante, obrigado!
Martin Ender


3

dc , 30 bytes

[???sAz1[[lAps.]s.<.dx]s.<.]dx

E / S: um número por linha.


3

Perl 5 , 31 bytes

30 bytes de código + -psinalizador.

s/\d+ (\d+) (\d+)/$2if$1<$&/ge

Experimente online!

Substitui cada grupo de 3 números ( \d+ (\d+) (\d+)) pelo terceiro ( $2) se o segundo ( $1) for menor que o primeiro ( $&) e nada diferente.


3

CJam , 15 bytes

{3/{)\:>{;}|}%}

Bloco anônimo que espera argumento na pilha e deixa o resultado na pilha.

Experimente online! (Executa todos os casos de teste)

Explicação

3/             e# Split the list into length-3 chunks.
  {            e# For each chunk:
   )           e#  Remove the last element.
    \:>        e#  Reduce the first 2 elements by greater than.
       {;}|    e#  If the first is not larger than the second, delete the third.
           }%  e# (end for)

3

Flak cerebral , 82 bytes

{([({}[{}()]<(())>)](<>)){({}())<>}{}{((<{}>))<>{}}{}<>{}{{}((<({}<>)<>>))}{}{}}<>

Experimente online!

# Until the stack is empty (input is guaranteed to not contain 0)
{

  # Push 1 for greater than or equal to 0
  ([({}[{}()]<(())>)](<>)){({}())<>}{}{((<{}>))<>{}}{}<>{}
  #  ^------^  This part is Top - (Second + 1)

  # If the second number was less than the first...
  {{}

     # Get ready to push 2 zeros
     ((<

       # Move the next number to the other stack
       ({}<>)<>

     # Push those 2 zeros
     >))}

     # Pop 2 values.
     # This is either 2 zeros, or a 0 and a "last number" that shouldn't be printed
     {}{}

# End loop
}

# Switch to the stack where we stored the numbers to be printed
<>

3

Gelatina , 10 bytes

s3µṪWx>/µ€

Experimente online!

ou

Verificar casos de teste

-3 bytes graças a @LeakyNun

Explicação

s3µṪWx>/µ€
s3         - split into groups of three
  µ     µ€ - on each group, do:
   ṪW      - return the third element as the only element of a list
     x     - repeat each element in that list the number of times
      >/   - corresponding to 1 if the second element of the group is greater than the first; 0 otherwise.



3

R, 37 bytes

Versão com a scan()qual eu não gosto, mas a torna mais curta.

x=scan();x[(i<--1:1)>0][x[!i]<x[i<0]]

Versão com a function()qual é mais fácil testar (41 bytes)

f=function(x)x[(i<--1:1)>0][x[!i]<x[i<0]]

Graças ao @ Giuseppe! Boa idéia para usar a reciclagem do índice.

Teste:

f(c())
f(c(1,2,3,4,5,6,7,8,9))
f(c(2,1,3,5,4,6,8,7,9))
f(c(3,1,4,1,5,9,2,6,5))
f(c(100,99,123))
f(c(123,123,456))
f(c(456,123,789))

Resultado:

> f(c())
NULL
> f(c(1,2,3,4,5,6,7,8,9))
numeric(0)
> f(c(2,1,3,5,4,6,8,7,9))
[1] 3 6 9
> f(c(3,1,4,1,5,9,2,6,5))
[1] 4
> f(c(100,99,123))
[1] 123
> f(c(123,123,456))
numeric(0)
> f(c(456,123,789))
[1] 789

você lê xa partir stdin usando x=scan()no início, em vez de definir uma função, você também pode simplesmente definir i=c(1,2,0)desde índices lógicos são reciclados ou seja,x=scan();i=c(1,2,0);x[!i][x[i>1]<x[i==1]]
Giuseppe


Obrigado @ Giuseppe! Não gosto dessa x=scan()abordagem, pois torna a entrada muito complicada. E eu não posso torná-lo repetível então.
djhurio

2
Certo, mas o objetivo é gerar um código o mais curto possível. Infelizmente para nós dois, alguém encontrou uma solução melhor!
Giuseppe

Heh, eu também tive a idéia de usar, matrix()mas de alguma forma eu não acreditava que seria possível abreviá-lo.
djhurio

3

JavaScript (ES6), 46 44 42 41 39 bytes

a=>a.filter((_,y)=>y%3>1&a[y-1]<a[y-2])
  • Economizou 2 bytes graças a Neil .

Tente

Insira uma lista de números separados por vírgula, sem espaços.

f=
a=>a.filter((_,y)=>y%3>1&a[y-1]<a[y-2])
i.oninput=_=>o.innerText=JSON.stringify(f(i.value.split`,`.map(eval)))
console.log(JSON.stringify(f([])))                  // []
console.log(JSON.stringify(f([1,2,3,4,5,6,7,8,9]))) // []
console.log(JSON.stringify(f([2,1,3,5,4,6,8,7,9]))) // [3,6,9]
console.log(JSON.stringify(f([3,1,4,1,5,9,2,6,5]))) // [4]
console.log(JSON.stringify(f([100,99,123])))        // [123]
console.log(JSON.stringify(f([123,123,456])))       // []
console.log(JSON.stringify(f([456,123,789])))       // [789]
<input id=i><pre id=o>


Explicação

a=>              :Anonymous function taking the input array as an argument via parameter a
a.filter((_,y)=> :Filter the array by executing a callback function on each element,
                  with the index of the current element passed through parameter y.
                  If the function returns 0 for any element, remove it from the array.
y%3>1            :Check if the modulo of the current index is greater than 1.
                  (JS uses 0 indexing, therefore the index of the 3rd element is 2; 2%3=2)
&                :Bitwise AND.
a[y-1]<a[y-2]    :Check if the element at index y-1 in array a
                  is less than the element at index y-2
)                :End filtering method

11
Funciona y%3>1&a[y-1]<a[y-2]?
Neil

Riscado 44 ainda é 44 #
Roman Gräf

Como assim, @ RomanGräf?
Shaggy


Um bug no "Arial", Helvetica Neue "Helvetica, sans-serif" - bem visto @Roman
flurbius

3

Casca , 8 bytes

ṁΓȯΓ↑<C3

Experimente online!

Explicação

Este programa está um pouco envolvido, então tenha paciência comigo.

ṁΓȯΓ↑<C3  Implicit input (list of integers).
      C3  Split into slices of length 3.
ṁ         Map over slices and concatenate results
 ΓȯΓ↑<    of this function, explained below.

A função ΓȯΓ↑<pega uma lista do comprimento 3 x = [a,b,c],. O primeiro Γdivide xem ae [b,c], e os alimenta como argumentos para a função ȯΓ↑<. Isso deve ser equivalente a ((Γ↑)<), mas devido a um bug / recurso do intérprete, na verdade é equivalente a (Γ(↑<)), interpretado como uma composição de Γe ↑<. Agora, aé alimentado para a última função usando aplicação parcial, a função resultante ↑<aé fornecida Γ, que desconstrói [b,c]em be [c]. Em seguida, bé alimentado para ↑<a, resultando em uma função que pega os primeiros b<aelementos de uma lista. Esta função é finalmente aplicada a [c]; o resultado é [c]se a>b, e[]de outra forma. Essas listas são concatenadas para formar o resultado final, que é impresso implicitamente.

Sem o "recurso", eu teria 9 bytes:

ṁΓoΓo↑<C3


2

MATL , 10 bytes

IeI&Y)d0<)

O resultado é exibido como números separados por espaços.

Experimente online!

Ou verifique todos os casos de teste . Isso exibe uma representação de string da saída, para que uma matriz vazia seja realmente vista como []. Observe que em MATL um número é igual a uma matriz singleton, portanto, [4]é mostrado como 4.

Explicação

Ie    % Implicit input. Reshape as a 3-row matrix (column-major order)
I&Y)  % Split into the third row and a submatrix with the other two rows
d     % Consecutive difference along each column of the submatrix
0<    % True for negative values
)     % Use as logical index into the original third row. Implicitly display

2

Röda , 15 bytes

{[_3]if[_2<_1]}

Röda é quase tão curta quanto as línguas de golfe ...

Isso pega três valores do fluxo e empurra o terceiro ( _3) de volta, se o segundo ( _2) for menor que o primeiro ( _1).

Os sublinhados são açúcar de sintaxe para forloops; portanto, o programa pode ser escrito como {{[a]if[b<c]}for a,b,c}ou mesmo {[a]for a,b,c if[b<c]}.

Nenhum link TIO, porque não funciona no TIO por algum motivo (embora funcione com a versão mais recente do Röda que antecede o desafio).


2

Java 7, 86 85 bytes

void c(int[]a){for(int i=-1;++i<a.length;)if(a[i++]>a[i++])System.out.println(a[i]);}

-1 byte graças a @ PunPun1000

Explicação:

Experimente aqui.

void c(int[]a){                  // Method with integer-array parameter and no return
  for(int i=-1;++i<a.length;)    //  Loop over the array in steps of three at a time
    if(a[i++]>a[i++])            //   If the value of the current index is larger than the next:
      System.out.println(a[i]);  //    Print the value on the third index
                                 //  End of loop (implicit / single-line body)
}                                // End of method

@ PunPun1000 Agora você só aumentou a iteração em 2 em vez de 3 e, portanto, deu resultados incorretos (como 3,9no caso de teste em 1,2,3,4,5,6,7,8,9vez de 3,6,9).
Kevin Cruijssen

11
@Kevin_Cruijssen Opa, você está certo. Você ainda pode salvar um byte usando o operador de incremento. Você só precisa começar em -1 Experimente online!
PunPun1000

@ PunPun1000 Ah, você está certo, boa captura. Obrigado!
Kevin Cruijssen

2

C #, 126 bytes

using System.Linq;i=>Enumerable.Range(0,i.Length/3).Select(u=>3*u).Where(u=>i[u]>i[u+1]).Select(u=>i[u+2]);

Se você deseja um programa inteiro com o método, seria 175 bytes :

using System.Linq;namespace S{class P{static System.Collections.IEnumerable X(int[]i)=>Enumerable.Range(0,i.Length/3).Select(u=>3*u).Where(u=>i[u]>i[u+1]).Select(u=>i[u+2]);}}

Economizou 7 bytes com a ajuda de TheLethalCoder


Você pode simplesmente imprimir os ...
Leaky Nun

@LeakyNun, é claro que eu poderia - mas por que deveria? Perguntei se é necessário, não é, e seria mais bytes, eu acho.
MetaColon

(int[]i)pode simplesmente inão haver necessidade do tipo.
TheLethalCoder

@TheLethalCoder Atualizou.
MetaColon 9/05

@MetaColon Você também não precisa dos aparelhos (i).
TheLethalCoder


1

CJam , 16 bytes

q~3/{~@@>S{;}?}%

A saída é mostrada como números separados por espaços.

Experimente online!

Explicação

q~               e# Read input list
  3/             e# List of sublists of length 3
   {         }%  e# Apply this to each sublist
    ~            e# Push sublist contents: 3 numbers
     @@          e# Rotate twice. This moves first two numbers to top
       >         e# Greater than?
        S{;}?    e# If so: push space (used as separator). Else: pop the third number
                 e# Implicitly display


1

JavaScript, 108 107 108 bytes

Esta é uma função JS anônima (lambda) válida. Adicione x=no início e chame like x([5,4,9,10,5,13]). Saídas como função return.

a=>(y=[],a.map((c,i)=>(i+1)%3?0:y.push(a.slice(i-2,i+1))),y.map(v=>v[1]<v[0]?v[2]:null).filter(c=>c|c==0))

O fragmento recebe a entrada como uma lista de números inteiros separados por vírgula.

x=a=>(y=[],a.map((c,i)=>(i+1)%3?0:y.push(a.slice(i-2,i+1))),y.map(v=>v[1]<v[0]?v[2]:null).filter(c=>c|c==0))
martin.oninput = e => { dennis.innerHTML = x(martin.value.split`,`.map(c=>parseInt(c,10))) }
<input type=text id=martin><pre id=dennis>


Qual o sentido de postar uma solução mais longa e usar martine denniscomo id?
Freira vazando

@LeakyNun Shaggy postou sua solução enquanto eu trabalhava na minha. Mas isso não foi motivo para não postar minha solução. Quanto ao uso dos nomes como identificação, pensei que seria engraçado.
Arjun

Isso não funciona [5,4,9,10,5,13].
Shaggy

@ Shaggy Esse foi um problema com a implementação do trecho de caso de teste; nada de errado com a solução. Na verdade, o valor do elemento de entrada é sempre uma string. Então, dividir a string ,resultou em uma matriz de strings em vez de números! A solução está perfeitamente bem. Somente o trecho do caso de teste estava errado. Eu consertei isso agora. Obrigado por apontar isso! :)
Arjun

Ah, sim, isso explica o problema! Graças a você , @Arjun.
Shaggy

1

Perl5.8.9, 73 60 bytes

while(@F){@b=splice@F,0,3;$b[1]<$b[0]&&print$b[2]}print"-"

(58 + 2 para o sinalizador 'n' para ler o arquivo inteiro e a para divisão automática). Supõe que a entrada seja linhas de números separados por espaço

Redução graças ao Dada. Incluindo a impressão no final para visibilidade, isso economizaria 8 bytes, se não.


Agradável! Tenha seu merecido +1!
Arjun

O formato de saída é bastante flexível, você realmente não precisa colocar isso print"\n"no final. Além disso, você pode fazer $b[1]<$b[0]&&print"$b[2] "while@b=splice@a,0,3para salvar 7 bytes. Finalmente, você pode usar -asinalizador em vez de fazer @a=split(ele fará o mesmo automaticamente e armazenará o resultado em @Fvez de @a); com o Perl 5.8.9, você precisará, -naenquanto o Perls recente -aé suficiente. Isso deve levá-lo a 47-48 bytes.
Dada

ah, eu não sabia sobre -a. Eu ainda acho que eu deveria fazer uma linha de produção por linha de entrada, a saída é bastante incomprehensbile de outra forma
Tom Tanner

1

Clojure, 43 bytes

#(for[[a b c](partition 3 %):when(< b a)]c)

Entediante :/


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.