Sua tarefa aqui será implementar uma função ¹ que forme uma permutação nos números inteiros positivos (A bijeção dos inteiros positivos para si mesmos). Isso significa que cada número inteiro positivo deve aparecer exatamente uma vez na permutação. O problema é que sua função deve ter uma probabilidade maior de gerar um número ímpar que um número par.

Agora isso pode parecer estranho ou impossível. Certamente existem tantos números ímpares quanto números pares? E embora essa intuição esteja correta para conjuntos finitos, na verdade não é válida para conjuntos infinitos. Por exemplo, tome a seguinte permutação:

1 3 2 5 7 4 9 11 6 13 15 8 17 19 10 21 23 12 25 27 14 29 31 16 33 35 18 37 39 20 41 43 22 45 47 24 49 51 26 53 55 ...

Se você tomar qualquer subseção da sequência com tamanho maior que , terá pelo menos tantos números ímpares quanto números pares, portanto, parece que a probabilidade de qualquer termo aleatório ser ímpar é maior do que a de ser par. Você também notará que todos os números pares ou ímpares aparecerão na sequência e podem aparecer apenas uma vez. Assim, a sequência é uma verdadeira permutação.$1$

Definição de Probabilidade

Para evitar confusão ou ambiguidade, explicarei claramente o que se entende por probabilidade nesta questão.

Digamos que temos uma função $f$ . A probabilidade de um número ser ímpar será definida como o limite da razão de membros ímpares do conjunto para o tamanho do conjunto $f\{1\dots n\}$ pois $n$ tende para o infinito.

Por exemplo, a função acima mencionada teria uma probabilidade de ser ímpar de $2/3$ .

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

Desafios extras

Aqui estão algumas idéias divertidas para brincar e talvez tentar implementar. Estes são apenas para diversão e não afetam a pontuação de forma alguma. Algumas delas nem sequer são soluções válidas para esse desafio, e uma resposta que inclui apenas soluções para os desafios 2 ou 3 não é uma resposta válida e pode ser excluída .

• Escreva uma permutação com uma probabilidade ímpar de $1$ . (isso é possível)

• Escreva uma permutação que tenha mais números ímpares do que números pares em para qualquer mas que tenha uma probabilidade ímpar de .$f\{1\dots n\}$$n$$1/2$

• Escreva uma permutação que não tenha probabilidade definida (ou seja, não há limite).

^{1: Aqui, função significa programa ou função. É apenas um pedaço de código que recebe entrada e produz saída.}

Geléia , 7 bytes

Æf^<¥4P

Swaps 2 s e 3 s em fatoração privilegiada da entrada. A probabilidade de chances é de 2/3 .

Experimente online!

Como funciona

Æf^<¥4P  Main link. Argument: n

Æf       Compute all prime factors of n, with duplicates.
    ¥4   Combine the two links to the left into a dyadic chain and call it with
         right argument 4.
   <       Compare each prime factor with 4. Yields 1 for 2 and 3, 0 otherwise.
  ^        Bitwise XOR the results with the corresponding prime factors.
         This maps 2 to 3, 3 to 2, and all other primes to themselves.
      P  Take the product of the resulting primes.

Casca , 11 10 bytes

-1 byte graças a Leo, e uma função ligeiramente diferente

Isso tem uma probabilidade ímpar de 1

!uΣz:NCNİ1

Experimente online!

Indexa a sequência:

[1,2,3,5,7,9,11,4,13,15,17,19,21,23,25,27,29,6,31,33]
1 odd, 1 even, 5 odd, 1 even, 9 odd, 1 even, 13 odd...

Explicação

!               Index the following sequence (1-indexed)
 u              remove duplicates                     [1,2,3,5,7,9,11,4,13,15...]
  Σ              Concatenate                          [1,1,2,3,5,3,7,9,11,4,13..]
   z:            Zipwith append                       [[1,1],[2,3,5],[3,7,9,11]..
     N          Natural numbers
      CNİ1      Odd numbers cut into lists of lengths [[1],[3,5],[7,9,11]...]
                corresponding to the Natural numbers

Haskell, 35 34 32 bytes

f n=n:2*n+1:2*n+3:f(n+2)
(f 0!!)

Implementa a sequência de exemplo [1,3,2,5,7,4,9,11,6,13,15,8,17,19,10,21,...].

Experimente online!

Para referência: versão antiga, 34 bytes (-1 byte graças a @xnor):

(!!)$do e<-[0,2..];[e,2*e+1,2*e+3]

Experimente online!

Casca , 8 bytes

!uΣzeİ1N

Experimente online!

Isso implementa a sequência de exemplo ( 1,3,2,5,7,4...).

Explicação

!uΣzeİ1N
   ze       zip together
     İ1       the odd numbers
       N      with the natural (positive) numbers
  Σ         flatten the resulting list
 u          remove duplicates
!           index into the obtained sequence with the input

Todo mundo faz o Desafio 1, então vamos fazer os outros dois.

Perl 6 , 26 bytes - Desafio 2

{($_==1)+$_-(-1)**($_%%2)}

Experimente online!

É apenas 1 3 2 5 4 7 6...Em um número par de termos, sempre existem mais 2 números ímpares que pares. Em um número ímpar, mais 1. No entanto, isso tem claramente um limite de (n+2)/(2n+2) -> ½.

Perl 6 , 70 bytes - Desafio 3

{((1,),(2,4),->@a,@ {@(map(@a[*-1]+2*(*+1),^(4*@a)))}...*).flat[$_-1]}

Experimente online!

É certo que isso é terrivelmente jogado de golfe. Indexa uma sequência que contém 2⁰ números ímpares, depois 2¹ pares, 2² ímpares, depois 2³ pares e assim por diante.

A probabilidade após n desses "blocos", se n for ímpar, é (2⁰ + 2² + 2⁴ + ... + 2ⁿ⁻¹) / (2ⁿ-1). A soma no numerador é igual a ⅓ (4 ^{½ (n + 1)} - 1) = ⅓ (2 ^{n + 1} - 1). Portanto, a probabilidade após um número ímpar de blocos é ⅔ (no limite).

Se adicionarmos mais um bloco (e calcularmos uma contagem par deles n + 1), no entanto, não adicionamos números ímpares (o numerador permanece o mesmo), mas agora existem (2 ^{n + 1} - 1) números no total . Os parênteses são cancelados e obtemos a probabilidade de ⅓ (no limite).

Aparentemente, isso deve ter 2 pontos de cluster diferentes, ⅓ e ⅔, para garantir que o limite não exista, mas isso realmente não prova isso. Minha tentativa de fazer uma prova sólida e rigorosa pode ser encontrada nesta resposta do Math.SE: https://math.stackexchange.com/a/2416990/174637 . Bashing erros é bem-vinda.

Perl 6 , 39 bytes - O principal desafio.

{my$l=$_ div 3;$_%3??2*($_-$l)-1!!2*$l}

Experimente online!

Embora eu tenha postado essa resposta por causa dos desafios 2 e 3, que ofereceram um agradável quebra-cabeça matemático, há um requisito estrito para que todas as respostas contenham uma solução para o desafio principal. Aqui está então.

Esta é a sequência de exemplo.

Flacidez cerebral , 120 bytes

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

Experimente online!

Executa a seguinte função:

Esta função gera a sequência

2 4 1 6 3 5 7 8 9 11 13 15 17 19 21 10 23 25 27 29...

A função tem uma probabilidade ímpar de 1

R, 82 bytes (desafio extra 1)

f<-function(n){if(sqrt(n)==floor(sqrt(n))){2*sqrt(n)}else{2*(n-floor(sqrt(n)))-1}}

Experimente Online!

Se a entrada é um quadrado perfeito, fornece um número par. Caso contrário, fornece um número ímpar. Os quadrados perfeitos têm densidade natural 0, o que significa que essa sequência fornece números ímpares com probabilidade 1.

C (gcc) , 29 bytes

f(n){return n&3?n+n/2|1:n/2;}

Experimente online!

Cada quarto número é par:

1 3 5   7 9 11   13 15 17   19 21 23   25 27 29
      2        4          6          8          10

Desafio extra 1, 52 bytes

f(n,i){for(i=0;n>>i/2;i+=2);return n&n-1?2*n-i-1:i;}

Experimente online!

Retorna 2 * (x + 1) se n for igual a 2 ^x e números ímpares consecutivos, caso contrário:

    1   3 5 7   9 11 13 15 17 19 21    23 25
2 4   6       8                     10      

Flak cerebral , 140 138 136 bytes

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

Experimente online!

Explicação

Isso executa uma função semelhante à sugerida na pergunta.

2 3 1 4 7 5 6 11 9 8 15 13 10 17 15 ...

Funciona principalmente com base em um snippet que fiz para rolar a pilha para pilhas de tamanho 3.

(({}(({}({}))[({}[{}])]))[({}[{}])])

Montamos duas pilhas, uma com valores de acumulador (duas ímpares pares) e uma com os números 4 4 2. A cada iteração, rolamos as duas pilhas e adicionamos a parte superior da pilha esquerda à parte superior da pilha direita.

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

Isso aumentará cada número ímpar em 4 e o número par em 2. À medida que passamos, obtemos um padrão de 2 ímpares 1 pares, com cada número inteiro positivo sendo atingido. Assim, apenas repetimos os ntempos com na entrada. Isso tem uma probabilidade assintótica de 2/3 .

Gelatina , 10 bytes

ÆE;0ṭ2/FÆẸ

A probabilidade de chances é de 2/3 .

Experimente online!

Como funciona

ÆE;0ṭ2/FÆẸ  Main link. Argument: n

ÆE          Compute the exponents of n's prime factorization.
  ;0        Append a 0.
     2/     Reduce all pairs by...
    ṭ         tack, appending the left argument to the right one.
            This inverts all non-overlapping pairs of exponents.
       F    Flatten the result.
        ÆẸ  Consider the result a prime factorization and compute the corresponding
            integer.

C, 80 bytes

#define R if(k++==n)return
i,j,k;f(n){for(i=k=1,j=2;;i+=4,j+=2){R i;R i+2;R j;}}

Implementação do exemplo permutação da pergunta.

Experimente online!

Lote, 36 bytes

@cmd/cset/an=%1*2,(-~n*!!(n%%3)+n)/3

Implementa a sequência dada na pergunta.

JavaScript, 23 bytes

n=>n/2+n/2%2+(n%4&&n-1)

Saída: 1, 3, 5, 2, 7, 9, 11, 4, 13, 15, 17, 6, 19, 21, 23, 8 ...

• Para todos n = 4k:
  • f (n) = n / 2 = 2k
• Para todos n = 4k + b
  • Qual é o valor de f (n) = n / 2 + b / 2 + n - 1 = 3/2 * (4k + b) + 1/2 * b - 1 = 6k + 2b - 1

Desafio 2:

n=>n^(n>1)

Saída: 1, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14

CJam (21 bytes)

{2b_(&!\_,2*\1$~+2b?}

Demonstração online mostrando as 32 primeiras saídas. Este é um bloco anônimo (função).

Essa também é uma solução para o desafio 1: os números mapeados para números pares são as potências de 2, de modo que a densidade dos números pares nas primeiras n saídas é lg (n) / n que tende a zero.

Dissecação

{         e# Declare a block; let's call the input x
  2b      e#   Convert to base 2
  _(&     e#   Copy, pull out first digit (1) and set intersection with rest
  !       e#   Boolean not, so empty set (i.e. power of 2) maps to 1 and non-empty
          e#   to 0
  \_,2*   e#   Take another copy, find its length, and double it
  \1$~+   e#   Take the original base 2 array and append ~(2L) = -2L-1
  2b      e#   Convert from base 2, to get 2x-2L-1
  ?       e#   Take the 2L if it was a power of 2, and the 2x-2L-1 otherwise
}

Perl 40 bytes

$,=$";$i=4;{say$i-3,$i/2,($i+=4)-5;redo}

Conduta cerebral , 88 bytes

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

Experimente online!

Explicação

Isso implementa a mesma função da minha última resposta, mas usa o modelo FIFO da Brain-Flueue para cortar alguns cantos. Aqui estão os dois primeiros termos que ele gera.

2 3 1 4 7 5 6 11 9 8 15 13 10 17 15 ...

A primeira parte do código é apenas um pouco de configuração, colocamos 0,-1,-3na primeira pilha e 2,4,4na segunda pilha. O 2,4,4será usado para alternar entre números pares e ímpares, como fiz na minha resposta Brain-Flak.

Em seguida, repetimos n vezes, adicionando sempre o topo da pilha esquerda à pilha direita. Como o Brain-Flueue usa filas em vez de empilhar, os valores rolam naturalmente à medida que os tocamos, impedindo a necessidade de código extra.

Python 2 , 46 104 55 bytes

lambda n:2*((n-int(n**.5))+.5,n**.5-1)[n!=1>0==n**.5%1]

Experimente online!

Leia mal a pergunta, agora implementou corretamente uma função que pode ser usada para gerar uma sequência em vez de uma que gera uma sequência. Também excluído 0do conjunto de possíveis saídas.

A probabilidade de encontrar um número inteiro positivo ímpar agora converge para 1.

Geléia , 9 bytes

Ḥ€’ĖUẎQ⁸ị

Experimente online!

Implementos 1, 3, 2, 5, 7, 4, 9, 11, 6, ...(probabilidade 2/3).

05AB1E , 11 bytes

·ÅÉā‚ø˜Ù¹<è

Experimente online!

Pitão , 9 bytes

*Fmxd<d4P

Experimente aqui! ou Teste mais de uma vez!

Você pode usar esse código para verificar a proporção de números ímpares até um determinado ponto. Substitua 10000pelo seu limite desejado (não o configure muito mais, porque há erros de memória).

Km*Fmxk<k4PdS10000clf%T2KlK

Experimente aqui .

O exposto acima fornece aproximadamente 0,667 . A verdadeira probabilidade de ocorrências ímpares é 2/3 . Essa abordagem é uma implementação equivalente da resposta de Dennis .

Explicação

*Fmxd<d4P   Full program.

        P   Prime factors.
  m         Map over ^.
   x        Bitwise XOR between:
    d          The current prime factor.
     <d4       The integer corresponding to the boolean value of current factor < 4.
*F          Product of the list.

Java 8, 20 bytes

n->n%4>0?n+n/2|1:n/2

Porto da resposta C de @nwellnhof .
Algumas coisas que tentei acabaram sendo alguns bytes mais longos ou ligeiramente incorretos.

Implementos: 1,3,5,2,7,9,11,4,13,15,17,6,19,21,23,8,25,27,29,10,31,33,35,12,37,...
com probabilidade de 3/4.

Experimente aqui.

Lua, 67 53 bytes

Explicação que vem quando eu terminar de jogar isso :)

Este programa pega um número inteiro via argumentos da linha de comando como entrada e imprime o enésimo elemento da sequência de exemplo em STDOUT

n=...print(n%3<1 and n/3*2or n+math.floor(n/3)+n%3-1)

Explicações

n=...                              -- shorthand for the argument
print(                             -- prints out the result of the following ternary
     n%3<1                         -- if n is divisible by 3
       and n/3*2                   -- prints out the corresponding even number
       or n+math.floor(n/3)+n%3-1) -- else prints out the odd number

Os números pares dessa sequência são o nnúmero pares e o nmúltiplo de 3; portanto, a fórmula n%3*2é suficiente para gerá-los.

Para números ímpares, é um pouco mais difícil. Com base no fato de podermos encontrá-los, dependendo da corrente n, temos a seguinte tabela:

n       |  1   2   4   5   7   8   10   11  
target  |  1   3   5   7   9   11  13   15
target-n|  +0  +1  +1  +2  +2  +3  +3   +4

Vamos chamar o valor target-n i, podemos ver que a cada vez n%3==2, ié incrementado. Lá vai a nossa fórmula:

n+math.floor(n/3)+n%3-1

Os números ímpares são baseados nnos quais adicionamos i.

O valor de iincrementos na mesma taxa da divisão euclidiana em 3, com um deslocamento. math.floor(n/3)nos fornece a taxa de incremento e n%3-1o deslocamento, fazendo com que aconteça em n%3==2vez de n%3==0.