O que vem depois?


15

Dada uma lista de números inteiros separados por espaço, sua tarefa é encontrar o próximo número inteiro na sequência. Cada número inteiro na sequência é o resultado da aplicação de uma única operação matemática ( +, -, *ou /) para o número inteiro anterior, e cada sequência é composta por um número variável de tais operações (mas não mais do que 10). Nenhuma sequência terá mais que a metade do comprimento da sequência de números inteiros; portanto, cada sequência de operações será exibida pelo menos duas vezes para confirmação.
A entrada será via stdin (ou promptpara soluções JavaScript).

Aqui estão alguns exemplos explicativos.

Entrada:

1 3 5 7 9 11

Resultado:

13

Bastante fácil, este. Todos os valores são anteriores +2.

Entrada:

1 3 2 4 3 5 4 6 5 7 6

Ouput:

8

Duas etapas nesta sequência, +2então -1.

Entrada:

2 6 7 3 9 10 6 18 19 15 45 46

Resultado:

42

Três passos - *3, +1, -4.

Casos de teste

Aqui estão mais alguns casos de teste:

Entrada:

1024 512 256 128 64 32 16

Resultado:

8

Entrada:

1 3 9 8 24 72 71 213 639

Resultado:

638

Entrada:

1 2 3 4 5 2 3 4 5 6 3 4 5 6 7

Resultado:

4

Entrada:

1 2 4 1 3 9 5 8 32 27 28 56 53 55 165 161 164 656 651 652 1304

Resultado:

1301

Eu tenho uma solução Scala não gasta (42 linhas) que postarei em alguns dias.

Este é o código-golfe - a resposta mais curta vence.


A divisão é garantida como exata?
Peter Taylor

@ Peter Sim. Cada etapa resultará em um número inteiro.
Gareth

Mas se a etapa for "/ 3", é garantido que o restante será sempre 0?
22611 Peter Peter Taylor

@ Peter Sim, o restante será sempre 0 #
Gareth

Respostas:


12

Golfscript, 203 138 caracteres

~]0{).2$.);[\(;]zip\/zip{.{~-}%.&({-}+\{;{.0={.~\%{.~%{;0}{~/{/}+}if}{~\/{*}+}if}{~!{;}*}if}%.&(\{;;0}/}{\;}if}%.{!}%1?)!{0}*}do\@)\,@%@=~

Isso usa muito mais if s do que um programa Golfscript padrão, e sua operação é bastante enigmática, então aqui está uma versão comentada (mas não destruída, exceto pela adição de espaço em branco e comentários):

~]0
# Loop over guesses L for the length of the sequence
{
    # [x0 ... xN] L-1
    ).
    # [x0 ... xN] L L
    2$.);[\(;]zip
    # [x0 ... xN] L L [[x0 x1][x1 x2]...[x{N-1} xN]]
    \/zip
    # [x0 ... xN] L [[[x0 x1][xL x{L+1}]...][[x1 x2][x{L+1} x{L+2}]...]...]
    {
        # [x0 ... xN] L [[xi x{i+1}][x{i+L} x{i+L+1}]...]
        # Is there an operation which takes the first element of each pair to the second?
        # Copy the pairs, work out each difference, and remove duplicates
        .{~-}%.&
        # Turn the first difference into an operation
        ({-}+\
        # If there was more than one unique difference, look for a multiplication
        {
            ;
            # [x0 ... xN] L [[xi x{i+1}][x{i+L} x{i+L+1}]...]
            # Do something similar, but working out multiplicative factors
            # Note that if we have [0 0] it could be multiplication by anything, so we remove it.
            # However, they can't all be [0 0] or we'd have only one unique difference
            {
                # [0     0   ] =>
                # [0     _   ] => 0     # a "false" value, because it can't possibly be multiplication
                # [a     a.b'] => {b'*}
                # [a'.b  b   ] => {a'/}
                # [_     _   ] => 0     # ditto
                # This is the obvious place to look for further improvements
                .0={.~\%{.~%{;0}{~/{/}+}if}{~\/{*}+}if}{~!{;}*}if
            }%.&
            # If we have one unique multiplication, even if it's false, keep it.
            # Otherwise discard them and replace them with false.
            (\{;;0}/
        }
        # There was only one unique difference. Discard the pairs
        {\;}if
        # operation - one of 0, {d+}, {m*}, {M/}
    }%
    # [x0 ... xN] L [op0 ... op{L-1}]
    # Is any of the operations false, indicating that we couldn't find a suitable operation?
    .{!}%1?
    # [x0 ... xN] L [op0 ... op{L-1}] idxFalse
    # If idxFalse is -1 then all the ops are ok, and we put a false to exit the loop
    # Otherwise one op failed, so we leave the array of ops, which is non-false, to be popped by the do.
    )!{0}*
}do
# [x0 ... xN] L [op0 ... op{L-1}]
\@)\,@%@=~
# op{(len(Xs)-1)%L} (Xs[-1])

Minha submissão original foi a seguinte, com 88 caracteres:

~]:x;2.{;).(2base(;{[{--}{@*\.!+/}]=}%[x.(;2$]zip\,<{~++}%x,.@[*x\]zip<{~~}%)\x(;=!}do\;

No entanto, isso tenta calcular as operações a partir da primeira ocorrência de cada uma; portanto, se a operação for multiplicação ou divisão e o argumento na primeira vez que for 0, ele será quebrado.


1
Muito obrigado por postar uma explicação! Eu tenho procurado por programas Golfscript dissecados para que eu possa tentar entender melhor eles.
Migimaru

6

Haskell, 276 261 259 257 243 caracteres

Aqui está a minha solução ineficiente. Funciona em números inteiros ilimitados (e delimitados). Esta solução funciona corretamente com a divisão não exata (por exemplo 5 / 2 = 2:).

import Control.Monad
main=interact$show.n.q read.words
f=flip
q=map
_%0=0
x%y=div x y
s b=[1..]>>=q cycle.(f replicateM$[(+),(*),(%)]>>=f q[-b..b].f)
m l x s=[y!!l|y<-[scanl(f($))(x!!0)s],x==take l y]
n x=(s(maximum$q abs x)>>=m(length x)x)!!0

Como funciona: eu crio todas as sequências possíveis de (possíveis) operações. Depois, testo a sequência de números de entrada para ver se a sequência gerada criará a entrada. Se isso acontecer, retorne o próximo número na sequência. O código sempre retornará uma resposta derivada de uma menor seqüência de operações. Isso acontece porque a lista de sequências de operações é gerada nessa ordem. É arbitrário (mas consistente) decidir entre os laços. Por exemplo, o código retorna 6ou 8para a sequência 2 4.

Ungolfed:

import Control.Monad

main :: IO ()
main = print . next . map read . words =<< getLine

opSequences :: Integral a => a -> [[a -> a]]
opSequences bound = [1 ..] >>= map cycle . (`replicateM` (ops >>= (`map` args) . flip))
  where
    ops = [(+), (*), \x y -> if y == 0 then 0 else div x y]
    args = [-bound .. bound]

match :: (MonadPlus m, Integral a) => [a] -> [a -> a] -> m a
match ns opSeq = guard (ns == take len ms) >> return (ms !! len)
  where
    n0 = ns !! 0
    len = length ns
    ms = scanl (flip ($)) n0 opSeq

next :: Integral a => [a] -> a
next ns = (opSequences bound >>= match ns) !! 0
  where
    bound = maximum $ map abs ns

Boa idéia de como lidar com a divisão não exata.
Peter Taylor

Foi um efeito colateral acidental. Procurar uma solução foi apenas minha ideia inicial de como resolver esse problema; para mim, parecia uma tarefa mais simples do que calcular a resposta.
Thomas Eding

É Control.Monad -> Monadpossível? E como sobreinteract$show.n.q read.words
FUZxxl

6

Python, 333 366 ... 315 303 278 269 261 246 caracteres

n=map(float,raw_input().split())
y=len(n)-1
l=1
def O(f):
 p,q=n[f:y:l],n[f+1::l]
 for a,b in zip(p,q):
    for x in((b-a).__add__,(b/(a or 1)).__mul__):
     if map(x,p)==q:return x
while 1:
 if all(map(O,range(l))):print int(O(y%l)(n[y]));break
 l+=1

Cria operação com o primeiro par de números e verifica em outros pares. Armazena todas as operações e, se todas tiverem êxito, aplica a operação apropriada no último elemento da lista.

Editado: passa no teste do mal :-) Agora procure por operação em todas as posições.


Agradável. Passa em todos os meus testes, mas não o particularmente ruim de Peter Taylor:0 0 1 2 3 6 7 14
Gareth

0 0 0 0 1 0 0 0 0 1não sai 0.
Thomas Eding

@ trinithis Essa entrada não está em conformidade com as especificações. A sequência de operações deve repetir completamente pelo menos uma vez.
Gareth

1
Oooh, aqui está uma melhoria divertida: lambda x:x+b-a-> (b-a).__add__. Pena que é apenas um personagem, estou aprendendo muito sobre python fazendo isso.
Clueless

1
Tornar limplicitamente global economiza muito: pastie.org/2416407
Clueless

4

Pitão, 309 305 295 279 caracteres

Lida com todos os casos de teste originais, bem como com o de Peter Taylor 0 0 1 2 3 6 7 14:

l=map(int,raw_input().split())
i=v=0
while v<1:
 v=i=i+1
 for j in range(i):
    p=zip(l[j::i],l[j+1::i])
    d,r=set(q[1]-q[0]for q in p),set(q[1]*1./(q[0]or 1)for q in p if any(q))
    m,n=len(d)<2,len(r)<2
    v*=m+n
    if(len(l)-1)%i==j:s=l[-1]+d.pop()if m else int(l[-1]*r.pop())
print s

Ungolfed, com saída de depuração (muito útil para verificar a correção):

nums = map(int,raw_input().split())
result = None

for i in range(1,len(nums)/2+1):
    print "-- %s --" % i
    valid = 1
    for j in range(i):
        pairs = zip(nums[j::i], nums[j+1::i])
        print pairs

        diffs = [pair[1] - pair[0] for pair in pairs]
        # this is the tough bit: (3, 6) -> 2, (0, 5) -> 5, (5, 0) -> 0, (0, 0) ignored
        ratios = [float(pair[1])/(pair[0] or 1) for pair in pairs if pair[0] != 0 or pair[1] != 0]

        if len(set(diffs))==1:
            print "  can be diff", diffs[0]
            if (len(nums) - 1) % i == j:
                result = nums[-1] + diffs.pop()
        elif len(set(ratios))==1:
            print "  can be ratio", ratios[0]
            if (len(nums) - 1) % i == j:
                result = int(nums[-1]*ratios.pop())
        else:
            print "** invalid period **"
            valid=0
    if valid and result is not None:
        break

print result

Uso:

echo 0 0 1 2 3 6 7 14 | python whatcomesnext.py

Voto a favor, embora estritamente falando a entrada deva ser via stdin, em vez de argumentos de comando.
Gareth

Isso realmente me deixa encurtar o programa por quatro personagens :)
Clueless

Poucos caracteres, i = v = 0 e enquanto v == 0:
Ante

@ Obrigado, pensei que você não poderia fazer isso em python porque a atribuição não é uma expressão, mas é um boato útil para o golfe. Guias literais como o recuo do segundo nível também ajudam.
Clueless

Eu não sou um Pythoner, mas você parece estar usando booleanos como números inteiros em algumas expressões e, no entanto, não pode usar o número inteiro v como booleano no teste while. Isso está certo? Se assim for, certamente v<1funciona como um guarda.
23411 Peter Taylor

2

Ruby 1.9 (437) (521) (447) (477)

Funciona para todos os casos de teste, incluindo o "mal". Vou jogar mais tarde.

Edição: Percebi que há outro caso que eu não estava lidando corretamente - quando a continuação precisa usar a operação "mistério". A sequência2 0 0 -2 -4 -6 estava retornando inicialmente 0 em vez de -12. Eu já consertei isso.

EDIT: Corrigimos mais alguns casos extremos e reduzimos o código para 447.

EDIT: Ugh. Tinha que adicionar algum código para lidar com outras seqüências "más", como0 0 0 6 18 6 12

def v(c,q);t=*q[0];q.size.times{|i|f=c[z=i%k=c.size]
f=c[z]=(g=q[z+k])==0??_:((h=q[z+k+1])%g==0?"*(#{h/g})":"/(#{g/h})")if f==?_
t<<=f==?_?(a=q[i];b=q[i+1].nil?? 0:q[i+1];(a==0&&b==0)||(a!=0&&(b%a==0||a%b==0))?b:0):eval(t.last.to_s+f)}
*r,s=t
(p s;exit)if q==r
end
s=gets.split.map &:to_i
n=[[]]
((s.size-1)/2).times{|i|a,b=s[i,2]
j=["+(#{b-a})"]
j<<=?_ if a==0&&b==0
j<<="*#{b/a}"if a!=0&&b%a==0
j<<="/#{a/b}"if a*b!=0&&a%b==0
n=n.product(j).map(&:flatten)
n.map{|m|v(m*1,s)}}

1

Scala

Esta é a solução que eu vim com:

object Z extends App{var i=readLine.split(" ").map(_.toInt)
var s=i.size
var(o,v,f)=(new Array[Int](s),new Array[Double](s),1)
def d(p:Int,j:Array[Int]):Unit={if(p<=s/2){def t(){var a=new Array[Int](s+1)
a(0)=i(0)
for(l<-0 to s-1){o(l%(p+1))match{case 0=>a(l+1)=a(l)+v(l%(p+1)).toInt
case _=>a(l+1)=(a(l).toDouble*v(l%(p+1))).toInt}}
if(a.init.deep==i.deep&&f>0){f^=f
println(a.last)}}
o(p)=0 
v(p)=j(1)-j(0)
t
d(p+1,j.tail)
o(p)=1
v(p)=j(1).toDouble/j(0).toDouble
t
d(p+1,j.tail)}}
d(0,i)
i=i.tail
d(0,i)}

Ungolfed:

object Sequence extends App
{
    var input=readLine.split(" ").map(_.toInt)
    var s=input.size
    var (ops,vals,flag)=(new Array[Int](s),new Array[Double](s),1)
    def doSeq(place:Int,ints:Array[Int]):Unit=
    {
        if(place<=s/2) 
        {
            def trysolution()
            {
                var a=new Array[Int](s+1)
                a(0)=input(0)
                for(loop<-0 to s-1)
                {
                    ops(loop%(place+1))match
                    {
                        case 0=>a(loop+1)=a(loop)+vals(loop%(place+1)).toInt
                        case _=>a(loop+1)=(a(loop).toDouble*vals(loop%(place+1))).toInt
                    }
                }
                if(a.init.deep==input.deep&&flag>0)
                {
                    flag^=flag
                    println(a.last)
                }
            }
            ops(place)=0
            vals(place)=ints(1)-ints(0)
            trysolution
            doSeq(place+1,ints.tail)
            ops(place)=1
            vals(place)=ints(1).toDouble/ints(0).toDouble
            trysolution
            doSeq(place+1,ints.tail)
        }
    }
    doSeq(0,input)
    input=input.tail
    doSeq(0,input)
}

Como eu o invoco? echo "0 0 1 2 3 6 7 14" | scala Sequencemantém a tela preta.
usuário desconhecido

@user unknown scala Sequencee, em seguida, insira a sequência e pressione enter.
Gareth

Ah, você escreveu no comentário das perguntas, que não resolve esse específico - ele funciona com eco-pipe como acima para as questões solucionáveis.
usuário desconhecido

1

Scala 936

type O=Option[(Char,Int)]
type Q=(O,O)
type L=List[Q]
val N=None
def t(a:Int,b:Int):Q=if(a>b)(Some('-',a-b),(if(b!=0&&b*(a/b)==a)Some('/',a/b)else N))else
(Some('+',b-a),(if(a!=0&&a*(b/a)==b)Some('*',b/a)else N))
def w(a:Q,b:Q)=if(a._1==b._1&&a._2==b._2)a else
if(a._1==b._1)(a._1,N)else
if(a._2==b._2)(N,a._2)else(N,N)
def n(l:L):Q=l match{case Nil=>(N,N)
case x::Nil=>x
case x::y::Nil=>w(x,y)
case x::y::xs=>n(w(x,y)::xs)} 
def z(l:L,w:Int)=for(d<-1 to w)yield
n(l.drop(d-1).sliding(1,w).flatten.toList)
def h(s:L):Boolean=s.isEmpty||(s(0)!=(N,N))&& h(s.tail)
def j(s:L,i:Int=1):Int=if(h(z(s,i).toList))i else j(s,i+1)
def k(b:Int,o:Char,p:Int)=o match{case'+'=>b+p
case'-'=>b-p
case'*'=>b*p
case _=>b/p}
val e=getLine 
val i=e.split(" ").map(_.toInt).toList
val s=i.sliding(2,1).toList.map(l=>t(l(0),l(1)))
val H=n(s.drop(s.size%j(s)).sliding(1,j(s)).flatten.toList)
val c=H._1.getOrElse(H._2.get)
println (k(i(i.size-1),c._1,c._2))

ungolfed:

type O = Option[(Char, Int)]

def stepalize (a: Int, b: Int): (O, O) = (a > b) match {
   case true => (Some('-', a-b), (if (b!=0 && b * (a/b) == a) Some ('/', a/b) else None)) 
   case false=> (Some('+', b-a), (if (a!=0 && a * (b/a) == b) Some ('*', b/a) else None)) }

def same (a: (O, O), b: (O, O)) = {
  if (a._1 == b._1 && a._2 == b._2) a else
  if (a._1 == b._1) (a._1, None) else 
  if (a._2 == b._2) (None, a._2) else 
  (None, None)}

def intersection (lc: List[(O, O)]): (O, O) = lc match {
  case Nil => (None, None)
  case x :: Nil => x
  case x :: y :: Nil => same (x, y)
  case x :: y :: xs  => intersection (same (x, y) :: xs)} 

def seriallen (lc: List[(O, O)], w: Int= 1) =
  for (d <- 1 to w) yield 
    intersection (lc.drop (d-1).sliding (1, w).flatten.toList)

def hit (s: List[(O, O)]) : Boolean = s match {
  case Nil => true 
  case x :: xs => (x != (None, None)) && hit (xs)}

def idxHit (s: List[(O, O)], idx: Int = 1) : Int =
  if (hit (seriallen (s, idx).toList)) idx else 
    idxHit (s, idx+1)

def calc (base: Int, op: Char, param: Int) = op match {
  case '+' => base + param
  case '-' => base - param
  case '*' => base * param
  case _   => base / param}

def getOp (e: String) = {
  val i = e.split (" ").map (_.toInt).toList
  val s = i.sliding (2, 1).toList.map (l => stepalize (l(0), l(1)))
  val w = idxHit (s)
  val hit = intersection (s.drop (s.size % w).sliding (1, w).flatten.toList)
  val ci = hit._1.getOrElse (hit._2.get)
  val base = i(i.size - 1)
  println ("i: " + i + " w: " + w + " ci:" + ci + " " + calc (base, ci._1, ci._2))
}

val a="1 3 5 7 9 11"
val b="1 3 2 4 3 5 4 6 5 7 6"
val c="2 6 7 3 9 10 6 18 19 15 45 46"
val d="1024 512 256 128 64 32 16"
val e="1 3 9 8 24 72 71 213 639"
val f="1 2 3 4 5 2 3 4 5 6 3 4 5 6 7"
val g="1 2 4 1 3 9 5 8 32 27 28 56 53 55 165 161 164 656 651 652 1304"
val h="0 0 1 2 3 6 7 14"
val i="0 0 0 0 1 0 0 0 0 1 0"

List (a, b, c, d, e, f, g, h, i).map (getOp)

Falha miseravelmente no de Peter Taylor h, mas não vejo a possibilidade de curar o programa em um período de tempo razoável.


Ajudaria reduzi-lo se você tratasse -como um caso especial +e /como um caso especial *? Minha maneira de passar a entrada de Peter Taylor (e similar) era cortar o primeiro número da sequência e tentar novamente. Ainda não tive tempo de ver como o seu programa funciona para saber se isso ajudaria no seu.
Gareth

Eu acho que ajudaria, mas apenas para esse caso especial. Uma série que contenha a multiplicação nula posteriormente, como -1, 0, 0, 1, 2, 3, 6, 7, 14precisará de uma cura diferente.
usuário desconhecido
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.