Enumeração de número inteiro tonto

25

Seu desafio hoje é produzir um determinado termo de uma sequência enumerando todos os números inteiros. A sequência é a seguinte: Se temos uma função indexada em 0 gerando a sequência f(n)e ceil(x)é a função de teto, então f(0) = 0; abs(f(n)) = ceil(n/2); sign(f(n))é positivo quando ne ceil(n/2)são pares ou ímpares.

Para ajudar a entender essa sequência, os primeiros termos são os seguintes: 0 1 -1 -2 2 3 -3 -4 4 5 -5 -6 6 7 -7...

Sua tarefa é escrever um programa que use um número inteiro ne produza o ntermo th da sequência. A entrada pode ser indexada apenas em 0 ou 1.

Casos de teste (indexados 0):

0  =>  0
1  =>  1
2  => -1
3  => -2
4  =>  2
5  =>  3

Isso é código-golfe , o menor número de bytes vence!

code-golf  sequence  integer 
— Pavel
fonte
— sergiol 15/09/17
Parece que o inverso de uma função de dobramento
— sergiol

Respostas:

8

SOGL V0.12 , 8 6 bytes

I».»⌡±

Experimente aqui! ou tente os primeiros números (alterados um pouco para que funcionem)
indexados em 0.

Explicação:

I       increment the input
 »      floor divide by 2
  .     push the original input
   »    floor divide by 2
    ⌡   that many times
     ±    negate

Ou mais simples:

(input + 1) // 2 negated input // 2 times
        I     »     ±      .     »    ⌡
— dzaima
fonte
3
Não demorou um minuto!
— NieDzejkob 15/09
6
Eu ».»estou no telefone I».»⌡±.
— Jonathan Allan
@JonathanAllan Eu não entendo ._.
— Pavel
4

C, 25 bytes

f(n){return~n/2*~-(n&2);}
— orlp
fonte
Você pode salvar 4 bytes atribuindo seu valor de retorno ao primeiro parâmetro, em vez de usar a palavra-chave return. f(n){n=~n/2*~-(n&2);}
— Cleblanc 15/09
5
@cleblanc Não é assim que C funciona.
— orlp 15/09
2
gcc -O0o x86-64 compila a versão do @ cleblanc com instruções que deixam o resultado da multiplicação em eax( godbolt.org/g/dztKPV ), mas seria uma x86-64 gcc -O0resposta, não uma resposta em C. Eu não voto C respostas que quebram com a otimização ativada, especialmente a última expressão estúpida como porcaria de valor de retorno. Mesmo se é assim que o gcc funciona, não é assim que o C funciona.
— 6266 Peter Cordes #
Faça um ponteiro. Você não precisa de otimizações se os valores original e final não estiverem na pilha.
— precisa saber é o seguinte
1
@ mreff555 Esse seria um método de IO fora do padrão (embora aceitável) e não seria mais curto.
— orlp
3

Pyke , 6 bytes

heQeV_

Experimente aqui!

Usa a abordagem de dzaima ... Beats Ties Jelly!

Explicação

h      - Increment the input, which is implicit at the beginning.
 e     - Floor halve.
  Q    - Push the input.
   e   - Floor halve.
    V_ - Apply repeatedly (V), ^ times, using negation (_).
       - Output implicitly.

Os bytes codificado-hex equivalentes seria: 68 65 51 65 56 5F.

— Mr. Xcoder
fonte
3

Mathematica, 24 bytes

(s=⌈#/2⌉)(-1)^(#+s)&

-14 bytes de @Misha Lavrov

— J42161217
fonte
1
Usar Boolee OddQtem o efeito de converter números ímpares em 1 e números pares em 0, mas você não precisa disso aqui: potências de -1 fornecem a resposta certa para todos os números ímpares. Então você pode reduzir esse passo para (-1)^Tr@{#,s}ou apenas (-1)^(#+s).
— Misha Lavrov
2

Lote, 29 bytes

@cmd/cset/a"%1/2^(%1<<30>>30)
— Neil
fonte
2

JavaScript (ES6), 18 bytes

f=
n=>n/2^(n<<30>>30)
<input type=number min=0 value=0 oninput=o.textContent=f(this.value)><pre id=o>0
Expandir snippet

Indexado a 0.

— Neil
fonte
2

Javascript, 17 bytes

n=>~n/2*~-(n&2)^0

Mostrar snippet de código

Este é 0 indexado. É um truque inteiramente a bit.

— recursivo
fonte
2

Cubicamente , 23 bytes

(Indexado 1)

FDF'$:7+8/0_0*0-8*7/0%6

Experimente online!

A principal dificuldade ao escrever código no Cubically são:

  • Existe apenas 1 variável gravável e
  • Obter constantes é difícil.

Então, esta solução calcula

((((n+1)/2)%2)*2-1)*n/2

onde /denota divisão inteira. Isso precisa apenas de 1 variável temporária e as constantes 1 e 2.

Explicação:

FDF'$:7+8/0_0*0-8*7/0%6
FDF'                      Set face value of face 0 to 2, and value of memory index 8 (cube is unsolved) to 1 (true = unsolved)
    $                     Read input
     :7                                 input
       +8                                + 1
         /0                        (        ) /2
           _0                     (             ) %2
             *0                  (                  ) *2
               -8                                        -1
                 *7             (                          ) *n
                   /0                                          /2
                     %6   Print
— user202729
fonte
2

TI-Basic (TI-84 Plus CE), 20 bytes

‾int(‾Ans/2)(1-2remainder(int(Ans/2),2

Um programa completo chamado como 5:prgmNAME.

O TI-Basic é uma linguagem tokenizada , todos os tokens usados ​​aqui são de um byte, exceto remainder(dois. ‾representa o token regativo, digitado com a (-)chave

Exemplos:

0:prgmNAME
 => 0
1:prgmNAME
 => 1
2:prgmNAME
 => -1
#etc

Explicação:

‾int(‾Ans/2)(1-2remainder(int(Ans/2),2
‾int(‾Ans/2)                           # -int(-X) is ciel(X), so ciel(Ans/2)
                          int(Ans/2)   # int(X) is floor(X), so floor(Ans/2)
                remainder(int(Ans/2),2 # 1 if floor(Ans/2) is odd else 0
            (1-2remainder(int(Ans/2),2 # -1 if floor(Ans/2) is odd, else 1
_int(_Ans/2)(1-2remainder(int(Ans/2),2 # -ciel(Ans/2) if floor(Ans/2) is odd, else ciel(Ans/2)

Mesma fórmula que uma função Y-var:

Y1= ‾int(‾X/2)(1-2remainder(int(X/2),2
— pizzapants184
fonte
2

dc , 16 bytes

1+d2~+2%2*1-r2/*

Tenho certeza de que há uma maneira de reduzir 0..1 a -1..1 em dc, mas não há ideias por enquanto.

Experimente online!

— cab404
fonte
2

Java 8, 15 bytes

n->~n/2*~-(n&2)

EDIT: Java é realmente a menor das linguagens não-golfe ?! o.Ô

Explicação:

Experimente aqui.

Vou usar a tabela abaixo como referência do que está acontecendo.

  1. ~né igual a -n-1.
  2. Como a divisão inteira em Java se baseia automaticamente em números inteiros positivos e em tetos em números inteiros negativos, ~n/2resultará na sequência0,-1,-1,-2,-2,-3,-3,-4,-4,-5,-5,...
  3. n&2resultará em 0ou 2, na sequência0,0,2,2,0,0,2,2,0,0,2,...
  4. ~-xé igual a (x-1), então ~-(n&2)(((n&2)-1) ) resulta na sequência-1,-1,1,1,-1,-1,1,1,-1,-1,1,...
  5. Multiplicar as duas sequências de ~n/2e ~-(n&2)dá é a sequência correta solicitada no desafio:0,1,-1,-2,2,3,-3,-4,4,5,-5,...

Tabela de visão geral:

n       ~n      ~n/2    n&2     ~-(n&2)     ~n/2*~-(n&2)
0       -1      0       0       -1          0
1       -2      -1      0       -1          1
2       -3      -1      2       1           -1
3       -4      -2      2       1           -2
4       -5      -2      0       -1          2
5       -6      -3      0       -1          3
6       -7      -3      2       1           -3
7       -8      -4      2       1           -4
8       -9      -4      0       -1          4
9       -10     -5      0       -1          5
10      -11     -5      2       1           -5
— Kevin Cruijssen
fonte
2

Flacidez Cerebral , 86 74 72 70 bytes

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

Experimente online!

Explicação

Existem duas partes nesse código. A primeira parte

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

faz o esforço da computação. Ele determina ceil(n/2)e se deve ou não negar a saída.

Para explicar como funciona, primeiro explicarei como calcular ceil(n/2). Isso pode ser feito com o seguinte código

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

Isso é decrescente de n cada vez que ele executa um not ( ([{}]())) em um contador e adiciona o contador a um resultado. Como o contador é zero na metade do tempo, apenas incrementamos todas as outras execuções, começando pela primeira.

Agora também quero calcular o sinal de nossos resultados. Para fazer isso, começamos outro contador. Este contador só muda de estado se o primeiro contador estiver desativado. Dessa forma, obtemos o padrão desejado. Colocamos esses dois contadores na pilha para facilitar a movimentação quando chegar a hora.

Agora que terminamos esse cálculo, nossa pilha fica assim

          parity(n)
ceil(n/2) sign

Então, precisamos trabalhar para obter o resultado pretendido nesta segunda parte.

<>{}{<>([{}])(<>)}<>
— Assistente de Trigo
fonte
1

QBIC , 27 26 bytes

g=(:+1)'\2`~(a-g)%2|?-g\?g

Explicação

g=          set worker var 'g' to
(:+1)           our index (plus one for the ceil() bit)
'\2`            integer divided by 2 (the int div needs a code literal: '..`
~(a-g)%2    IF index - temp result is odd (index 2 minus result 1 = 1)
|?-g        THEN PRINT g negated
\?g         ELSE PRINT g
— steenbergh
fonte
1

Clojure 122 bytes

Detalhado, mesmo quando jogado. Eu estou indo para o voto de simpatia aqui ... :-)

Golfe:

(defn d[n](let[x(int(Math/ceil(/ n 2)))y(cond(or(and(even? n)(even? x))(and(odd? n)(odd? x)))(Math/abs x):else(- 0 x))]y))

Ungolfed:

(defn dizzy-integer [n]
  (let [x   (int (Math/ceil (/ n 2)))
        y   (cond
                (or (and (even? n) (even? x))
                    (and (odd? n)  (odd? x))) (Math/abs x)
                :else (- 0 x)) ]
    y))
— Bob Jarvis - Restabelecer Monica
fonte
1

Excel VBA de 32 bits, 39 37 bytes

Função de janela imediata VBE anônima que recebe entrada da célula A1e sai para a janela imediata VBE

?[Sign((-1)^Int(A1/2))*Int((A1+1)/2)]

Restrito a 32 bits, pois A^Bnão é válido em 64 bits ( A ^Bé o mais próximo possível)

— Taylor Scott
fonte
O espaço entre (-1)e é ^[Intnecessário?
— Pavel
@ Pavel pelo menos para a versão de 64 bits do Excel VBA, sim; Mas disse que eu juro que não faz para a versão de 32 bits, mas infelizmente eu não posso teste que em qualquer do hardware que tem em mãos
— Taylor Scott
@Pavel - Eu olhei para ele sob um sistema de 32 bits (especificação de instalação padrão) e, nesse sistema, o espaço não é necessário - restringi a solução a 32 bits para aproveitar isso
— Taylor Scott
1
Legal! Você esqueceu de adicionar a contagem corrigida de bytes.
— Pavel
Opa, Obrigado @Pavel - Está consertado agora
— Taylor Scott
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.