Uma tabuada de multiplicação para Cheela

26

Os Cheela (do livro Ovo do Dragão, de Robert L. Forward) são criaturas que vivem na superfície de uma estrela de nêutrons. Seu corpo é plano e circular, com doze olhos no perímetro, então eles naturalmente usam um sistema de numeração de base 12.

Entre os Cheela, o cuidado com os filhotes e a educação dos jovens são tarefas realizadas pelos Antigos. Como o jovem Cheela precisa ser ensinado a multiplicar, os Antigos poderiam usar uma tabuada de multiplicação.

Sua tarefa é produzir uma tabela de multiplicação 12x 12na base 12, como a seguir. Letras maiúsculas Ae Bsão usadas para dígitos correspondentes a decimal 10 e 11respectivamente.

  1   2   3   4   5   6   7   8   9   A   B  10 
  2   4   6   8   A  10  12  14  16  18  1A  20 
  3   6   9  10  13  16  19  20  23  26  29  30 
  4   8  10  14  18  20  24  28  30  34  38  40 
  5   A  13  18  21  26  2B  34  39  42  47  50 
  6  10  16  20  26  30  36  40  46  50  56  60 
  7  12  19  24  2B  36  41  48  53  5A  65  70 
  8  14  20  28  34  40  48  54  60  68  74  80 
  9  16  23  30  39  46  53  60  69  76  83  90 
  A  18  26  34  42  50  5A  68  76  84  92  A0 
  B  1A  29  38  47  56  65  74  83  92  A1  B0 
 10  20  30  40  50  60  70  80  90  A0  B0 100

A saída deve ser impressa na tela. O formato deve ser o seguinte:

  1. Os números devem estar alinhados à direita em cada coluna.
  2. São permitidos espaços à esquerda antes da primeira coluna, espaços à direita após a última coluna ou uma nova linha após a última linha.
  3. A separação entre colunas pode ser um espaço (como mostrado acima) ou mais de um espaço, mas o número de espaços deve ser consistente entre as colunas. Para medir a separação de colunas, considere que os números exibidos incluem quaisquer espaços iniciais que possam ter sido necessários para atender ao requisito 1 (portanto, cada número ocupa três caracteres, o primeiro dos quais pode ser espaços). Por exemplo, a tabela com separação de dois espaços seria a seguinte:

      1    2    3    4    5    6    7    8    9    A    B   10 
      2    4    6    8    A   10   12   14   16   18   1A   20 
      3    6    9   10   13   16   19   20   23   26   29   30 
      4    8   10   14   18   20   24   28   30   34   38   40 
      5    A   13   18   21   26   2B   34   39   42   47   50 
      6   10   16   20   26   30   36   40   46   50   56   60 
      7   12   19   24   2B   36   41   48   53   5A   65   70 
      8   14   20   28   34   40   48   54   60   68   74   80 
      9   16   23   30   39   46   53   60   69   76   83   90 
      A   18   26   34   42   50   5A   68   76   84   92   A0 
      B   1A   29   38   47   56   65   74   83   92   A1   B0 
     10   20   30   40   50   60   70   80   90   A0   B0  100
    

O armazenamento do computador em uma estrela de nêutrons é muito caro, portanto, seu código deve usar o mínimo de bytes possível.

Desafio e bônus estendidos

Idealmente, seu código deve ser reutilizado em outras partes do universo, onde outros sistemas de numeração podem estar em uso. Para esse fim, o desafio é opcionalmente estendido da seguinte forma: Seu código aceita um número Ncomo entrada e gera uma tabela de multiplicação Nx Nna base N, com o formato acima.

A entrada pode ser do teclado ou como argumento de função. O programa ou função deve funcionar para 2N36, usando como dígitos nos primeiros Ncaracteres da seqüência 0, 1, ..., 9, A, B, ..., Z(maiúsculas letras)

Esse desafio estendido é opcional. Se você seguir esta rota, obtenha 20% de desconto na contagem de bytes (não é necessário arredondar para um número inteiro).

Luis Mendo
fonte
Luis agradável! =) Eu gostaria de ter o tempo para chegar a uma solução MATLAB, mas estou dimensões de medição de presente de Natal ocupado ...
Stewie Griffin
6
Boa sorte com aqueles chapéus esféricos! :-P
Luis Mendo
5
Because they have twelve eyes, they naturally use a base-12 numbering system.Bem, naturalmente. É por isso que usar binário, afinal ... ;-)
Tim Pederick
2
TimPederick Bom ponto :-D Para esclarecer: o corpo de uma Cheela é circular, eles podem remodelar os membros conforme necessário ... ter doze olhos é numericamente a característica mais distinta de seus corpos. Atualizei a pergunta, obrigado!
Luis Mendo
1
@LuisMendo romance muito bom, aquele que você cita. Starquake também não é ruim.
21816 lstefano

Respostas:

14

Pitão, 27 * 0,8 = 21,6

VSQsm.[\ 4jkXj*dNQrT99rG1SQ

Experimente online: Demonstração

Explicação:

VSQsm.[\ 4jkXj*dNQrT99rG1SQ   implicit: Q = input number
VSQ                           for N in [1, 2, ..., Q]:
    m                    SQ      map each number d in [1, 2, ..., Q] to:
              *dN                   N * d
             j   Q                  in base Q
            X     rT99rG1           replace the numbers [10, 11, ..., 98] with "A...Z"
          jk                        join to a string
     .[\ 4                          prepend spaces, so that the string has a length of 4
   s                             join all strings and print
Jakube
fonte
11

CJam, 33 * 0,8 = 26,4 bytes

ri:C,:)_ff{*Cb{_9>{'7+}&}%4Se[}N*

Teste aqui.

Isso usa a separação mínima necessária.

Explicação

ri:C        e# Read input, convert to integer, store in C.
,:)         e# Get range [1 2 ... C].
_ff{        e# 2D-map over all repeated pairs from that range...
  *Cb       e#   Multiply, convert to base C.
  {         e#   Map over the digits...
    _9>     e#     Check if the digit is greater than 9.
    {'7+}&  e#     If so, add the digit to the character "7", to get "A" to "Z".
  }%
  4Se[      e#   Pad the digits with spaces from the left, to 4 elements.
}
N*          e# Join with linefeeds.

Tabela de entrada 22(a maior que cabe na postagem sem uma barra de rolagem horizontal):

   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F   G   H   I   J   K   L  10
   2   4   6   8   A   C   E   G   I   K  10  12  14  16  18  1A  1C  1E  1G  1I  1K  20
   3   6   9   C   F   I   L  12  15  18  1B  1E  1H  1K  21  24  27  2A  2D  2G  2J  30
   4   8   C   G   K  12  16  1A  1E  1I  20  24  28  2C  2G  2K  32  36  3A  3E  3I  40
   5   A   F   K  13  18  1D  1I  21  26  2B  2G  2L  34  39  3E  3J  42  47  4C  4H  50
   6   C   I  12  18  1E  1K  24  2A  2G  30  36  3C  3I  42  48  4E  4K  54  5A  5G  60
   7   E   L  16  1D  1K  25  2C  2J  34  3B  3I  43  4A  4H  52  59  5G  61  68  6F  70
   8   G  12  1A  1I  24  2C  2K  36  3E  40  48  4G  52  5A  5I  64  6C  6K  76  7E  80
   9   I  15  1E  21  2A  2J  36  3F  42  4B  4K  57  5G  63  6C  6L  78  7H  84  8D  90
   A   K  18  1I  26  2G  34  3E  42  4C  50  5A  5K  68  6I  76  7G  84  8E  92  9C  A0
   B  10  1B  20  2B  30  3B  40  4B  50  5B  60  6B  70  7B  80  8B  90  9B  A0  AB  B0
   C  12  1E  24  2G  36  3I  48  4K  5A  60  6C  72  7E  84  8G  96  9I  A8  AK  BA  C0
   D  14  1H  28  2L  3C  43  4G  57  5K  6B  72  7F  86  8J  9A  A1  AE  B5  BI  C9  D0
   E  16  1K  2C  34  3I  4A  52  5G  68  70  7E  86  8K  9C  A4  AI  BA  C2  CG  D8  E0
   F  18  21  2G  39  42  4H  5A  63  6I  7B  84  8J  9C  A5  AK  BD  C6  CL  DE  E7  F0
   G  1A  24  2K  3E  48  52  5I  6C  76  80  8G  9A  A4  AK  BE  C8  D2  DI  EC  F6  G0
   H  1C  27  32  3J  4E  59  64  6L  7G  8B  96  A1  AI  BD  C8  D3  DK  EF  FA  G5  H0
   I  1E  2A  36  42  4K  5G  6C  78  84  90  9I  AE  BA  C6  D2  DK  EG  FC  G8  H4  I0
   J  1G  2D  3A  47  54  61  6K  7H  8E  9B  A8  B5  C2  CL  DI  EF  FC  G9  H6  I3  J0
   K  1I  2G  3E  4C  5A  68  76  84  92  A0  AK  BI  CG  DE  EC  FA  G8  H6  I4  J2  K0
   L  1K  2J  3I  4H  5G  6F  7E  8D  9C  AB  BA  C9  D8  E7  F6  G5  H4  I3  J2  K1  L0
  10  20  30  40  50  60  70  80  90  A0  B0  C0  D0  E0  F0  G0  H0  I0  J0  K0  L0 100
Martin Ender
fonte
8

MATL , 42 * 0,8 = 33,6

aviso Legal

Como o criador do idioma e o autor do desafio são os mesmos, esta resposta não é elegível para ganhar .

Para uma discussão sobre se essa restrição é necessária ou não, consulte esta meta questão .

Código

iXK:t!*Y)KYAZ{'(?<=^0*)0'32cYXZc32hK4*[]e!

Isso usa a separação mínima.

Exemplo

Tabela de multiplicação octal

>> matl
 > iXK:t!*Y)KYAZ{'(?<=^0*)0'32cYXZc32chK4*[]e!
 > 
> 8
  1   2   3   4   5   6   7  10 
  2   4   6  10  12  14  16  20 
  3   6  11  14  17  22  25  30 
  4  10  14  20  24  30  34  40 
  5  12  17  24  31  36  43  50 
  6  14  22  30  36  44  52  60 
  7  16  25  34  43  52  61  70 
 10  20  30  40  50  60  70 100 

Explicação

i              % input number, say n
XK             % copy to clipboard K
:              % vector 1, 2, ... n
t!*            % generate table: duplicate, transpose and multiply with broadcasting
Y)             % linearize into column array
KYA            % paste n from clipboard K. Convert to that base
Z{             % cell array of rows from array
'(?<=^0*)0'    % string literal for regexp replacement: find leading zeros
32c            % space character (for regexp replacement)
YX             % regexp replacement
Zc             % join cell array of strings into single string   
32             % code for space character. Conversion to char happens automatically
h              % concatenate horizontally
K4*[]e!        % paste n and multiply by 4. Reshape into 2D char array with 4*n columns

Edit: Experimente online!

Para executar no compilador online (em 19 de fevereiro de 2016), altere Y)para X:e remova []. Isso é para se adaptar às alterações que foram feitas no idioma desde que este desafio foi lançado.

Luis Mendo
fonte
"Como o criador do idioma e o autor do desafio são os mesmos, esta resposta não é elegível para ganhar". Eu não estava ciente dessa restrição. Isso é auto-imposto ou você encontrou um meta-consenso relevante?
Alex A.
1
@AlexA. Eu me auto-impus. Eu suspeitava que provavelmente houvesse algum tipo de acordo sobre isso. Do seu comentário, vejo que não há? O que quero dizer é: se você cria um idioma e depois lança um desafio, provavelmente está em uma posição vantajosa. O que geralmente é feito sobre isso? Não há nenhuma restrição?
Luis Mendo
Eu acho que você não está necessariamente em vantagem, desde que não planeje um desafio especificamente como um caso de uso para um built-in no seu idioma. Não conheço esse consenso de antemão, então recomendo perguntar sobre a meta.
Alex A.
@AlexA. Boa ideia! Feito
Luis Mendo
@AlexA. Se você quiser fazê-lo, talvez adicione sua sugestão como resposta lá?
Luis Mendo
5

Utilitários Bash + BSD, 36

echo Co{1..12}d{1..12}*p|dc|rs -j 12

O Works pronto para o uso no OS X. rspode precisar ser instalado nos sistemas Linux.

  • Bash se expande Co{1..12}d{1..12}*ppara Co1d1*p Co1d2*p Co1d3*p ... Co1d12*p ... Co12d12*p.
  • Esta é uma dcexpressão que gera os termos necessários. Codefine a base de saída como 12. dé usado como um separador entre números em vez de um espaço, portanto, não é necessário escapar na expansão de braçadeira. dna verdade duplica a parte superior da pilha, mas isso é efetivamente ignorado e descartado.
  • A saída de dcé uma única linha separada por espaço. rsremodela isso em uma matriz de 12x12. -jjustifica à direita cada termo.
Trauma Digital
fonte
4

Pitão, 36 bytes

Km+1dUJ12rjbmjkm.[\ 4j""m.Hbj*dkJKK1

Experimente aqui.

Azul
fonte
Você pode substituir Km+1dUJ12por KSJ12. Scria o intervalo [1, 2, ..., 12]. Você pode substituir ambos j""e jkpor s, desde a junção das strings. E outro byte: mude rjbm...K1para jmr...1K. Com essas alterações, você obtém 28 bytes:KSJ12jmrsm.[\ 4sm.Hbj*dkJK1K
Jakube
4

Python, 153 147 132 bytes * 0,8 = 105,6

def p(b):
 f=lambda n:(n>=b and f(n/b)or'')+chr((48,55)[n%b>9]+n%b)
 for i in range(b*b):print'%4s\n'[:3+(~i%b<1)]%f(~(i%b)*~(i/b)),

Até 132 bytes, graças aos conselhos de Tim Pederick! :)

basile-henry
fonte
Voto positivo, porque quanto mais eu respondo minha resposta , mais ela se parece com a sua!
precisa saber é o seguinte
Algumas melhorias possíveis: Use%-formattting em vez de rjust( '%4s'%f(...)). Veja se a impressão de cada valor com print ...,(e um printpara a nova linha) é menor que join. Nesse caso, tente recolher os loops .
precisa saber é o seguinte
Obrigado Tim, tentei recolher os loops (não conhecia esse truque). Não tenho a certeza que me faz ganhar muitos bytes se for o caso, mas é muito legal :)
Basile-henry
Vejo que você mudou para uma forma ternária (condição andA orB) dentro da função f, usando n>=b. Fiz isso até perceber que não era mais curto do que o que tinha antes, n//b... mas você está usando o Python 2! Você pode salvar um byte com n/b.
precisa saber é o seguinte
Sim essa é a razão que eu usei esta parte do seu código de exploração de python 2 a salvar mais um byte :)
Basile-henry
4

CJam, 38 33 32 38 * (.8) = 30,4 bytes

qi:D,:):L{Lf*{Db{_9>{55+c}&}%4Se[}%N}%

Experimente aqui.

(Parece muito semelhante ao de Martin agora.)

qi:D,:):L          e# Generate list of [1...input]
{Lf*               e# Take each number in that list and multiply it by the same list ([[1,2,3,..,input][2,4,6,...,input],...})
{Db{_9>{55+c}&}%   e# Convert each product to base input. If a digit value is >= 10 add 55 and convert to char, to make it a letter.
4Se[}%N}%          e# Pad each number with spaces to length 4. Put a newline after each row.
geokavel
fonte
3

Perl 6 , 60 bytes -20% = 48 bytes

{.put for (1..$_ X*1..$_)».base($_)».fmt('%3s').rotor($_)} # 60-20% = 48
#          ^-----------^ produce a list of two cross multiplied lists
#                        ^--------^ convert each to base N
#          format each to 3 spaces ^----------^
#         split the list into N element chunks ^--------^
#^-------^ print each of those on their own line with spaces between elements

(Isso é quase exatamente como eu escreveria, mesmo que não estivesse tentando fazê-lo o mais curto possível)

Uso:

{...}(2)
  1  10
 10 100
my &code = {...}
code 2;
  1  10
 10 100
{...}(12);
  1   2   3   4   5   6   7   8   9   A   B  10
  2   4   6   8   A  10  12  14  16  18  1A  20
  3   6   9  10  13  16  19  20  23  26  29  30
  4   8  10  14  18  20  24  28  30  34  38  40
  5   A  13  18  21  26  2B  34  39  42  47  50
  6  10  16  20  26  30  36  40  46  50  56  60
  7  12  19  24  2B  36  41  48  53  5A  65  70
  8  14  20  28  34  40  48  54  60  68  74  80
  9  16  23  30  39  46  53  60  69  76  83  90
  A  18  26  34  42  50  5A  68  76  84  92  A0
  B  1A  29  38  47  56  65  74  83  92  A1  B0
 10  20  30  40  50  60  70  80  90  A0  B0 100
{...}(18);
  1   2   3   4   5   6   7   8   9   A   B   C   D   E   F   G   H  10
  2   4   6   8   A   C   E   G  10  12  14  16  18  1A  1C  1E  1G  20
  3   6   9   C   F  10  13  16  19  1C  1F  20  23  26  29  2C  2F  30
  4   8   C   G  12  16  1A  1E  20  24  28  2C  2G  32  36  3A  3E  40
  5   A   F  12  17  1C  1H  24  29  2E  31  36  3B  3G  43  48  4D  50
  6   C  10  16  1C  20  26  2C  30  36  3C  40  46  4C  50  56  5C  60
  7   E  13  1A  1H  26  2D  32  39  3G  45  4C  51  58  5F  64  6B  70
  8   G  16  1E  24  2C  32  3A  40  48  4G  56  5E  64  6C  72  7A  80
  9  10  19  20  29  30  39  40  49  50  59  60  69  70  79  80  89  90
  A  12  1C  24  2E  36  3G  48  50  5A  62  6C  74  7E  86  8G  98  A0
  B  14  1F  28  31  3C  45  4G  59  62  6D  76  7H  8A  93  9E  A7  B0
  C  16  20  2C  36  40  4C  56  60  6C  76  80  8C  96  A0  AC  B6  C0
  D  18  23  2G  3B  46  51  5E  69  74  7H  8C  97  A2  AF  BA  C5  D0
  E  1A  26  32  3G  4C  58  64  70  7E  8A  96  A2  AG  BC  C8  D4  E0
  F  1C  29  36  43  50  5F  6C  79  86  93  A0  AF  BC  C9  D6  E3  F0
  G  1E  2C  3A  48  56  64  72  80  8G  9E  AC  BA  C8  D6  E4  F2  G0
  H  1G  2F  3E  4D  5C  6B  7A  89  98  A7  B6  C5  D4  E3  F2  G1  H0
 10  20  30  40  50  60  70  80  90  A0  B0  C0  D0  E0  F0  G0  H0 100
Brad Gilbert b2gills
fonte
Não é um especialista, mas é necessário o espaço entre 'for' e '(' necessário? É necessário recortar os espaços sempre que possível.)
J_F_B_M
@J_F_B_M Eu sempre tento remover os espaços primeiro. Portanto, se houver um espaço, é necessário. Se eu removesse o espaço, ele certamente não seria compilado, pois trataria for(como o início da chamada de uma sub-rotina nomeada em forvez da forconstrução do loop modificador . O que causaria um erro de compilação.
Brad Gilbert b2gills
Aprendi alguma coisa. Obrigado.
J_F_B_M
3

JavaScript (ES6) 84 (105-20%)

A maneira óbvia, para começar.

n=>{for(o=i=``;i++<n;o+=`
`)for(j=0;j++<n;)o+=(`   `+(i*j).toString(n)).slice(-4).toUpperCase();alert(o)}

Notas

  • É uma pena que js toString produza letras minúsculas
  • alert não é a melhor maneira de exibir a tabela, mas é a mais curta, pois há uma solicitação explícita para "exibir na tela"
  • Apenas retornar o valor seria um par de bytes menor.

Menos golfe

n=>{
  for(o='', i=0; i++<n; o+='\n')
    for(j=0;j++<n;)
       o+=('   '+(i*j).toString(n)).slice(-4).toUpperCase()
  alert(o)
}
edc65
fonte
3

Python 3, 126 - 20% = 100,8 bytes

A função externa,, té a que realmente imprime a tabela de multiplicação. A função interna,, ifaz a conversão de um número em uma base de 2 para 36.

def t(b):
 i=lambda n:(n>=b and i(n//b)or'')+chr(n%b+[48,55][n%b>9]);R=range(b)
 for r in R:print(*('%3s'%i(~r*~c)for c in R))

Gorjeta de chapéu ao Boomerang por sua solução e por uma dica de golfe. Evitei copiar qualquer coisa da solução do Boomerang, mas me permiti olhar para ela para ver onde eu poderia aparar mais. E mesmo antes disso, descobri que quanto mais jogava golfe, mais os meus começaram a se parecer com os do Boomerang!

Tim Pederick
fonte
Ótima solução! :) E você obtém uma pontuação melhor do que eu! Eu gosto do> 9 em vez do meu <10. Eu não estou muito familiarizado com python3 e expressões estreladas (eu tive que procurar isso). Eu amo o seu ~ truque, preciso começar a usar isso!
basile-henry
Testei um pouco sua solução e parece que não retorno mais do que dois dígitos n de base. Por exemplo, se você fizer print(i(15,12),i(120,12),i(144,12),i(150,12))seu código retorna em 13 A0 00 06vez de 13 A0 100 106. Infelizmente, a tarefa exige a impressão de um número n base de 3 dígitos (100). Não deve ser muito difícil de corrigir, mas pode adicionar alguns bytes ...
Basile-henry
@ Boomerang: <coça a cabeça> Acho que devo ter quebrado alguma coisa, então ... porque estava funcionando antes! A questão parece ser que não dará um 1 líder ... oh, espere, eu sei qual é o problema. Deveria ser n>=b, não n>b.
Tim Pederick
Encontrei outro truque para diminuir o código: defina i dentro de t (b) para que você possa remover o segundo argumento em i! Como esta: def t(b): i=lambda n:(n>=b and i(n//b)or'')+chr(n%b+[48,55][n%b>9]) R=range(b) for r in R:print(*('%3s'%i(~r*~c)for c in R))Eu gostaria de fazer isso na minha solução, mas agora ambas as nossas soluções são muito perto, pode muito bem melhorar a melhor um ^^
Basile-henry
@Boomerang: Ei, o seu foi o primeiro, e acho que o Python 2 oferece atalhos suficientes para que você ainda possa me ultrapassar. Mas obrigado pela ajuda!
Tim Pederick
3

Javascript (ES6) 96,8 93,6 bytes (20% de 117)

n=>{b='';for(i=0;i++<n;b+=`\n`)for(j=0;j++<n;)a=(i*j).toString(n).toUpperCase(),b+=' '.repeat(4-a.length)+a;alert(b)}

Explicação

n=>
    {                                     
      b='';                                    //clear table var at each run
      for(i=0;i++<n;b+=`\n`)                   //iterate through rows
        for(j=0;j++<n;)                        //iterate through cols
          a=(i*j).toString(n).toUpperCase(),   //get desired number
          b+=' '.repeat(4-a.length)+a";        //pad to right
    alert(b)                                   //display result
}

- salvou 4 bytes graças a @ edc65

Aᴄʜᴇʀᴏɴғᴀɪʟ
fonte
1
Basta usar {} e alert(b)sem no evalé mais curto. E, pelo menos, variável evitar a, é inútilb+=' '.repeat(4-a.length)+(i*j).toString(n).toUpperCase()
edc65
Obrigado 😊 Eu não vi a necessidade de exibi-lo, então para mim eval () era originalmente mais curto do que retornar o valor. @ edc65 no entanto, se eu evitar, acomo você calcula ...repeat(4-a.length)...?
Aᴄʜᴇʀᴏɴғᴀɪʟ
Desculpe, você está certa sobre. 1 + como está
edc65
2

MATLAB, 111 * 0,8 = 88,8 110 * 0,8 = 88 bytes

Minha estréia aqui:

@(N)disp(reshape(strrep(strrep([' ',strjoin(cellstr(dec2base([1:N]'*[1:N],N)))],' 0','  '),' 0','  '),4*N,N)')

Explicação:

[1:N]'*[1:N] faça a tabuada de multiplicação na base 10

dec2base([1:N]'*[1:N],N) converter para a base 12. A saída é uma matriz de caracteres com 0-s iniciais

strjoin(cellstr(dec2base(___))) converter em célula e voltar a char que une strings com espaço produzindo 1x575 string

[' ',strjoin(___)] anexar espaço para ter 576 elementos

strrep(___,' 0',' ')remova um zero inicial. Fazemos isso duas vezes porque temos strings com dois zeros à esquerda

reshape(___,4*N,N)' converter matriz de caracteres 1x576 em matriz de caracteres 48x12

disp(___) exibir o resultado sem ans =

Saída:

 1   2   3   4   5   6   7   8   9   A   B  10
 2   4   6   8   A  10  12  14  16  18  1A  20
 3   6   9  10  13  16  19  20  23  26  29  30
 4   8  10  14  18  20  24  28  30  34  38  40
 5   A  13  18  21  26  2B  34  39  42  47  50
 6  10  16  20  26  30  36  40  46  50  56  60
 7  12  19  24  2B  36  41  48  53  5A  65  70
 8  14  20  28  34  40  48  54  60  68  74  80
 9  16  23  30  39  46  53  60  69  76  83  90
 A  18  26  34  42  50  5A  68  76  84  92  A0
 B  1A  29  38  47  56  65  74  83  92  A1  B0
10  20  30  40  50  60  70  80  90  A0  B0 100 

Se não contamos a instrução N=12;, os 5*.8=4bytes são salvos. Além disso, se a ans =saída for tolerada, podemos remover o disp()salvamento de outros 6*0.8=4.8bytes. Claro, pode haver outras maneiras de salvar bytes :)

brainkz
fonte
Em geral, a anssaída é tolerada se a saída for um argumento de função. Mas, neste caso, o desafio diz que "a saída deve ser impressa na tela", portanto ansnão é permitido. Além disso, Ndeve ser tomado como uma entrada no desafio estendido. Você pode resolver isso usando uma função anônima:, @(n)disp(reshape(strrep(strrep([' ',strjoin(cellstr(dec2base([1:N]'*[1:N],N)))],' 0',' '),' 0',' '),4*N,N)')que você chamaria usandoans(12)
Luis Mendo
1
Ah, e bem-vindo ao site! :-)
Luis Mendo
@LuisMendo thanks! Vou editar a minha resposta com @ (N) notação
brainkz
2

Python 3: 166 161 152 - 20% = 121,6 bytes

Eu sei que é inferior às respostas existentes em Python, mas imaginei tentar. É a minha primeira vez postando neste site…

def t(b):
 r=range(1,b+1);f=lambda x:x and f(x//b)+chr((55,48)[x%b>9]+x%b)or''
 print('\n'.join(''.join(B)for B in(('%4s'%f(i*j)for j in r)for i in r)))
Teemu Piippo
fonte
Existem 3 parênteses de fechamento e 2 literais numéricos seguidos por espaços. Esses espaços são desnecessários. Caso contrário, boa primeira tentativa. BTW, Dicas para jogar golfe em Python é uma boa leitura.
manatwork
Bem-vindo ao PPCG.SE, mesmo que ele não supere outras respostas do Python, desde que seja diferente (não o mesmo algoritmo / idéia), você pode publicá-lo :).
precisa
@manatwork Thanks! Eu tenho mais 9 bytes com isso.
Teemu Piippo
2

APL, 32 31 × 0,8 = 24,8 bytes

{¯4↑¨⊃∘(⎕D,⎕A)¨¨⍵⊥⍣¯1¨∘.×⍨1+⍳⍵}

In origin 0. Em inglês:

  • ∘.×⍨1+⍳⍵: tabela de multiplicação
  • ⍵⊥⍣¯1¨: expressa na base ⍵ cada elemento da tabela de multiplicação
  • ⊃∘(⎕D,⎕A)¨¨: converte a tabela de vetores de números em uma tabela de vetores de caracteres
  • ¯4↑¨: alinhar à direita com o comprimento 4 de cada elemento do resultado

A rotina de impressão APL padrão faz a coisa certa.

      {¯4↑¨(⍵⊥⍣¯1¨∘.×⍨1+⍳⍵)⊃¨¨⊂⊂⎕D,⎕A}13
    1     2     3     4     5     6     7     8     9     A     B     C    10 
    2     4     6     8     A     C    11    13    15    17    19    1B    20 
    3     6     9     C    12    15    18    1B    21    24    27    2A    30 
    4     8     C    13    17    1B    22    26    2A    31    35    39    40 
    5     A    12    17    1C    24    29    31    36    3B    43    48    50 
    6     C    15    1B    24    2A    33    39    42    48    51    57    60 
    7    11    18    22    29    33    3A    44    4B    55    5C    66    70 
    8    13    1B    26    31    39    44    4C    57    62    6A    75    80 
    9    15    21    2A    36    42    4B    57    63    6C    78    84    90 
    A    17    24    31    3B    48    55    62    6C    79    86    93    A0 
    B    19    27    35    43    51    5C    6A    78    86    94    A2    B0 
    C    1B    2A    39    48    57    66    75    84    93    A2    B1    C0 
   10    20    30    40    50    60    70    80    90    A0    B0    C0   100 
lstefano
fonte
-1:{¯4↑¨⊃∘(⎕D,⎕A)¨¨⍵⊥⍣¯1¨∘.×⍨1+⍳⍵}
Adám 28/06/16
Em vez de "chars", você deve usar "bytes" com um link para meta.codegolf.stackexchange.com/a/9429/43319 .
Adám 28/06/16
1

Ruby, 69 66 caracteres - 20% = 52,8

->n{(r=1..n).map{|a|puts r.map{|b|"%4s"%(a*b).to_s(n).upcase}*''}}

Exemplo de execução:

2.1.5 :001 > ->n{(r=1..n).map{|a|puts r.map{|b|"%4s"%(a*b).to_s(n).upcase}*''}}[4]
   1   2   3  10
   2  10  12  20
   3  12  21  30
  10  20  30 100
homem a trabalhar
fonte
1

ksh93, 51 * 0.8 == 40.8 bytes

eval echo "'
' {"{1..$1}'..$((++n*$1))..$n%3..$1d}'

Isso deve funcionar até a base 64 (o maior radical suportado pelo ksh). Exemplos:

 $ n= ksh -s 12 <<\EOF
eval echo "'
' {"{1..$1}'..$((++n*$1))..$n%3..$1d}'
EOF


   1   2   3   4   5   6   7   8   9   a   b  10
   2   4   6   8   a  10  12  14  16  18  1a  20
   3   6   9  10  13  16  19  20  23  26  29  30
   4   8  10  14  18  20  24  28  30  34  38  40
   5   a  13  18  21  26  2b  34  39  42  47  50
   6  10  16  20  26  30  36  40  46  50  56  60
   7  12  19  24  2b  36  41  48  53  5a  65  70
   8  14  20  28  34  40  48  54  60  68  74  80
   9  16  23  30  39  46  53  60  69  76  83  90
   a  18  26  34  42  50  5a  68  76  84  92  a0
   b  1a  29  38  47  56  65  74  83  92  a1  b0
  10  20  30  40  50  60  70  80  90  a0  b0 100

 $ n= ksh -s 22 <<\EOF
eval echo "'
' {"{1..$1}'..$((++n*$1))..$n%3..$1d}'
EOF


   1   2   3   4   5   6   7   8   9   a   b   c   d   e   f   g   h   i   j   k   l  10
   2   4   6   8   a   c   e   g   i   k  10  12  14  16  18  1a  1c  1e  1g  1i  1k  20
   3   6   9   c   f   i   l  12  15  18  1b  1e  1h  1k  21  24  27  2a  2d  2g  2j  30
   4   8   c   g   k  12  16  1a  1e  1i  20  24  28  2c  2g  2k  32  36  3a  3e  3i  40
   5   a   f   k  13  18  1d  1i  21  26  2b  2g  2l  34  39  3e  3j  42  47  4c  4h  50
   6   c   i  12  18  1e  1k  24  2a  2g  30  36  3c  3i  42  48  4e  4k  54  5a  5g  60
   7   e   l  16  1d  1k  25  2c  2j  34  3b  3i  43  4a  4h  52  59  5g  61  68  6f  70
   8   g  12  1a  1i  24  2c  2k  36  3e  40  48  4g  52  5a  5i  64  6c  6k  76  7e  80
   9   i  15  1e  21  2a  2j  36  3f  42  4b  4k  57  5g  63  6c  6l  78  7h  84  8d  90
   a   k  18  1i  26  2g  34  3e  42  4c  50  5a  5k  68  6i  76  7g  84  8e  92  9c  a0
   b  10  1b  20  2b  30  3b  40  4b  50  5b  60  6b  70  7b  80  8b  90  9b  a0  ab  b0
   c  12  1e  24  2g  36  3i  48  4k  5a  60  6c  72  7e  84  8g  96  9i  a8  ak  ba  c0
   d  14  1h  28  2l  3c  43  4g  57  5k  6b  72  7f  86  8j  9a  a1  ae  b5  bi  c9  d0
   e  16  1k  2c  34  3i  4a  52  5g  68  70  7e  86  8k  9c  a4  ai  ba  c2  cg  d8  e0
   f  18  21  2g  39  42  4h  5a  63  6i  7b  84  8j  9c  a5  ak  bd  c6  cl  de  e7  f0
   g  1a  24  2k  3e  48  52  5i  6c  76  80  8g  9a  a4  ak  be  c8  d2  di  ec  f6  g0
   h  1c  27  32  3j  4e  59  64  6l  7g  8b  96  a1  ai  bd  c8  d3  dk  ef  fa  g5  h0
   i  1e  2a  36  42  4k  5g  6c  78  84  90  9i  ae  ba  c6  d2  dk  eg  fc  g8  h4  i0
   j  1g  2d  3a  47  54  61  6k  7h  8e  9b  a8  b5  c2  cl  di  ef  fc  g9  h6  i3  j0
   k  1i  2g  3e  4c  5a  68  76  84  92  a0  ak  bi  cg  de  ec  fa  g8  h6  i4  j2  k0
   l  1k  2j  3i  4h  5g  6f  7e  8d  9c  ab  ba  c9  d8  e7  f6  g5  h4  i3  j2  k1  l0
  10  20  30  40  50  60  70  80  90  a0  b0  c0  d0  e0  f0  g0  h0  i0  j0  k0  l0 100
ormaaj
fonte
0

Pyke, 14 bytes * 0,8 = 11,2 bytes, não competitivo

QhD]UA*MbQMl2P

Experimente aqui!

Explicação:

            - autoassign Q = eval_or_not_input()
QhD]        - [Q+1, Q+1]
    U       - nd_range(^)
     A*     - apply(*, ^)
       MbQ  - map(base(Q), ^)
          Ml2 - map(lower, ^)
          P - print_grid(^)

Ou 12 bytes sem o bônus

13D]UA*Mb12P
Azul
fonte
O desafio especifica letras maiúsculas
Luis Mendo