Inspirado por essa pergunta hoje cedo , gostaria de ver maneiras interessantes pelas quais várias linguagens de programação podem transformar um numpad em probabilidades. Geralmente, os jogos baseados em blocos permitem que você use um teclado numérico para se mover em qualquer direção com base em onde o seu personagem está atualmente. Ao criar uma IA para esses jogos, Math.random() * 8não é suficiente, então eu tive que ser um pouco criativo para fazer o movimento parecer um pouco natural.

Um numpad é definido como tal:

7 | 8 | 9
- - - - -
4 | x | 6
- - - - -
1 | 2 | 3

Observe que 5 é um número inválido, pois você não pode avançar para si mesmo.

Todos os exemplos usarão estas probabilidades: [50, 40, 30, 20, 10]

Se eu quisesse gerar probabilidades 8, ficaria assim:

40 | 50 | 40 
-- | -- | --
30 | xx | 30
-- | -- | --
20 | 10 | 20

A saída seria [20, 10, 20, 30, 30, 40, 50, 40](com 5 omitidos) ou [20, 10, 20, 30, null, 30, 40, 50, 40](com 5 presentes)

Se eu quisesse gerá-los 1, ficaria assim:

30 | 20 | 10
-- | -- | --
40 | xx | 20
-- | -- | --
50 | 40 | 30

A saída seria [50, 40, 30, 40, 20, 30, 20, 10](com 5 omitidos) ou [50, 40, 30, 40, null, 20, 30, 20, 10](com 5 presentes)

Você pode escrever um programa completo que recebe a entrada da maneira usual (linha de comando, stdin) e imprime a saída, ou pode escrever uma função com um argumento numérico, que imprime ou retorna a saída. Seu programa ou função deve aceitar um número - a posição a ser gerada. Você deve usar estas probabilidades: [50, 40, 30, 20, 10](elas não precisam ser codificadas).

O código mais curto em bytes vence. As brechas padrão não são permitidas. As respostas postadas no encadeamento vinculado não são permitidas. Espaços à direita ou à direita são permitidos. Você pode tratar a posição 4como ausente ou vazia, dependendo da sua preferência. Não sou muito exigente no formato de saída - imprima-o como sequências separadas por vírgula ou como uma matriz.

(Esta é a minha primeira pergunta, vá devagar comigo!)

CJam, 27 bytes

12369874s_$\_r#m<f{#4-z)0S}

Experimente on-line no intérprete CJam .

Idéia

Se percorrermos os dígitos em torno de 5 no sentido anti-horário, obteremos a sequência 12369874ou qualquer uma de suas rotações (dependendo do ponto de partida).

Depois de girar essa sequência para que o dígito de entrada n esteja na posição mais à esquerda, os dígitos na sequência rotativa têm as seguintes probabilidades:

50 40 30 20 10 20 30 40

Se considerarmos os índices desses dígitos, que são

 0  1  2  3  4  5  6  7

subtrair 4 de cada um para produzir

-4 -3 -2 -1  0  1  2  3

e pegue valores absolutos para obter

 4  3  2  1  0  1  2  3

só precisamos adicionar 1 e acrescentar um 0 para obter as probabilidades desejadas.

Código

12369874s                   e# Push "12369874".
         _$                 e# Push a sorted copy, i.e., "12346789".
           \                e# Swap it with the unsorted original.
            _r#             e# Find the index of the input in an unsorted copy.
               m<           e# Rotate the unsorted original that many units left.
                 f{       } e# For each character C in "12346789":
                            e#   Push the rotated string.
                   #        e#   Find the index of C.
                    4-      e#   Subtract 4.
                      z     e#   Compute the absolute value.
                       )    e#   Add 1.
                        0S  e#   Push a 0 and a space.

Prolog, 166 bytes

a(A,R):-I:J:K:L:M=50:40:30:20:10,B is abs(5-A),member(B:S,[4:[I,J,K,J,L,K,L,M],3:[J,I,J,K,K,L,M,L],2:[K,J,I,L,J,M,L,K],1:[J,K,L,I,M,J,K,L]]),(A/5>1,reverse(S,R);S=R).

Isso usa o fato de que o resultado para 9 é o inverso do resultado para 1, o mesmo para 2 e 8, 3 e 7 e 4 e 6. Existem padrões reconhecíveis para passar do resultado de 1 para os resultados de 2,3 e 4, mas tenho certeza de que seria mais longo codificar isso do que codificar as seqüências de 1 a 4, que foi o que eu fiz.

Exemplo: a(7,R).saídas R = [30, 20, 10, 40, 20, 50, 40, 30].

Python - 115

a=[50,40,30,20,10,20,30,40]
b=[0,1,2,7,8,3,6,5,4]
def v(n):
 c=8-b[n-1]
 return[(a[c:]+a[:c])[e]for e in b if e-8]

aé uma matriz com os valores em ordem ao redor do teclado numérico (no sentido anti-horário de 1) e bmapeia os números no teclado numérico para as posições ao redor dele. Com base no número de espaços ao redor do numpad para o número de entrada (determinado usando b), ele cria uma matriz com muitos elementos movidos da frente apara o final e depois usa bnovamente para reorganizar os elementos para corresponder aos números do numpad.

Pitão - 38 bytes

Usa a mesma técnica da resposta Python, exceto com a compactação básica para as duas matrizes.

J_jC"3ê"T*RTm@.<jC"<àR"T-8@JtQd.DJ4

Experimente aqui online .

Java, 190

void g(int n){int i[]={8,0,1,2,7,8,3,6,5,4};String v="54321234",s="";n=i[n];if(n>0)v=v.substring(8-n)+v.substring(0,8-n);for(n=0;n++<9;s=", ")if(n!=5)System.out.print(s+v.charAt(i[n])+"0");}

String v mantém as probabilidades (divididas por 10) em ordem horária no sentido horário, com a entrada = 1 sendo o padrão 50.

int[]iconverte a entrada em um índice em v. Por exemplo, v.charAt(i[1])é 5. As entradas 0 e 5 são inválidas, portanto, i [0] e i [5] têm um valor de espaço reservado de 8, que é o índice para '\ 0' no final de v.

Giro os números em v para a direita pelo valor i [n] e depois imprimo as probabilidades como seqüências de caracteres separadas por vírgula.