Tarefa

Dada uma letra (A, B, C) e um número (0-10), imprima o tamanho do tamanho de papel padrão correspondente (Séries A e B) ou o tamanho do envelope padrão correspondente (série C) em milímetros no formato aaaa x bbbbonde aaaae bbbbsão as medidas de largura e altura em milímetros, conforme ISO216 (Série A e B) ou ISO296 (Série C)

Para facilitar as coisas, citarei a tabela de tamanhos de papel da Wikipedia

ISO paper sizes in portrait view
Format  A series    B series    C series
Size     mm × mm      mm × mm    mm × mm
0       841 × 1189  1000 × 1414 917 × 1297
1       594 × 841    707 × 1000 648 × 917
2       420 × 594    500 × 707  458 × 648
3       297 × 420    353 × 500  324 × 458
4       210 × 297    250 × 353  229 × 324
5       148 × 210    176 × 250  162 × 229
6       105 × 148    125 × 176  114 × 162
7        74 × 105     88 × 125   81 × 114
8        52 × 74      62 × 88    57 × 81
9        37 × 52      44 × 62    40 × 57
10       26 × 37      31 × 44    28 × 40

Então, exemplos de entrada e saída:

**Test case 1**
Input: A4
Output: 210 x 297

**Test Case 2**
Input: B6
Output: 125 x 176

**Test Case 3**
Input: C2
Output: 458 x 648

Coisas a serem observadas:

1. O formato "210 x 297" ou "1000 x 1414" etc. Embora esse seja o formato preferível, você pode optar por omitir o "x" da sua saída, ou seja, na forma de uma matriz ou dois números ou o que lhe agrada. desde que a medição da largura seja emitida antes da altura.
2. A proporção entre a altura e a largura é aproximadamente equivalente à raiz quadrada de 2; portanto, no cálculo das alturas, a largura é multiplicada por sqrt (2) e depois arredondada para cima ou para baixo até o milímetro mais próximo, resultando em as medições na tabela acima. Isso pode ajudar a melhorar seu código.
3. Em tamanhos sucessivos para uma série, à medida que você desce pela tabela, a largura de um tamanho se torna a altura do próximo. Isso também pode ajudá-lo a aprimorar seu código.

Regras:

1. Isso é código-golfe. As regras padrão se aplicam como resultado. A pontuação será baseada na contagem de bytes. A contagem mais baixa vencerá.
2. Sem brechas tolas , nós já estivemos lá antes ... Nós não vamos passar por isso novamente.
3. Se você pode codificá-lo, considere também anexar um link a uma instância de trabalho do seu código, para que outros programadores e jogadores de golfe possam aprender como seu código funciona. Isso não é obrigatório, mas eu gostaria de incentivar outras pessoas a fazer isso para que todos possamos aprender uns com os outros. Eu certamente adoraria aprender mais sobre os idiomas de outros golfistas sempre que possível.

Boa sorte.

JavaScript (ES7), 57 bytes

Guardado 1 byte graças a @WallyWest

s=>n=>[n,n-1].map(x=>.707**x*{A:841,B:1e3,C:917}[s]+.2|0)

C (gcc) , 113 111 90 78 70 bytes

Ele precisa -lmser executado no TIO, mas funciona bem no meu computador sem a opção.

Economizou 20 bytes graças a pizzapants184 .

Retorne valores por ponteiro.

f(a,b,c,d)int*c,*d;{float x=1e3*pow(.707,b+a%3/4.)+.2;*c=x,*d=x/.707;}

Explicação:

f(a,b,c,d)int*c,*d;{          // calling by char, but receive as int
    float x = 1e3 * pow(.707, // float gives enough precision 
            a % 3 / 4.        // series: a%3/4.=.5,0,.25 when a=65,66,67
            + b) - .2;        // magic number to get correct roundings
    *c = x, *d = x / .707;
}

Python 2 , 103 97 93 84 83 81 bytes

def f(l,n):w=[841,1000,917][ord(l)-65];h=int(w/.707);exec"w,h=h/2,w;"*n;print w,h

Experimente online!

Lote, 105 bytes

@set/aA=1189,B=1414,C=1297,h=%1,w=h*29/41
@for /l %%i in (1,1,%2)do @set/at=w,w=h/2,h=t
@echo %w% x %h%

41/29 √ √2

JavaScript, 53 bytes

L=>N=>[N+1,N].map(p=>1091/2**(p/2+~{B:2,C:1}[L]/8)|0)

f=

L=>N=>[N+1,N].map(p=>1091/2**(p/2+~{B:2,C:1}[L]/8)|0)

document.write('<table><tr><th><th>A<th>B<th>C',[...Array(11)].map((_,i)=>'<tr><th>'+i+['A','B','C'].map(j=>'<td>'+f(j)(i)).join``).join``);

Salve muitos bytes usando um formato de saída alternativo, graças a Neil.

Java (OpenJDK 8) , 59 bytes

f->s->new double[]{s=1e3*Math.pow(.707,s+f%3/4d)-.2,s/.707}

Experimente online!

Inspirado pela entrada C de @Colera Su , depois aprimorado por mim.

• 14 bytes salvos graças a Kevin Cruijssen

MATL , 34 33 30 bytes

917 841 1000.5vjo)t2X^*hi2/W/k

Experimente online! ou Verifique todos os casos de teste

Guardado 4 bytes graças a Luis Mendo

APL (Dyalog) , 31 28 bytes

-2 graças a ngn.

Corpo do programa completo. Assume ⎕IO( I ndex O rigin) como sendo 0, o padrão em muitos sistemas. Solicita o número e a letra, ambos do STDIN. Imprime em STDOUT.

⌊.2+1E3÷2*8÷⍨('BC'⍳⍞)+4×⎕-⍳2

Experimente online!

Uma versão ligeiramente modificada permite testar todas as possibilidades de uma só vez: Experimente online!

⍳2 primeiros dois Ɩ ndices, isto é, 0 e 1

⎕- subtrair isso da entrada numérica

4× multiplique quatro com isso

(… )+ Adicione o seguinte

 ⍞ entrada de caracteres…

 'BC'⍳ … 'S ndex nesta string ("A" dará 2, como o índice além do último)

8÷⍨ divida isso por 8

2* elevar 2 ao poder desse

1E3÷ 1000 dividido por isso

.2+ adicione ⅕ a isso

⌊ piso (arredondado para baixo)

Befunge, 69 56 55 bytes

"}"8*~3%:"L"*7vv\p00-1_$..@
")"*":":-*!!\+<>2/00g:^:&\/

Experimente online!

Explicação

Não temos o luxo de ponto flutuante ou algo parecido com uma função de potência no Befunge, portanto calculamos o tamanho base para o caractere de formato especificado, f , da seguinte forma:

fn = f % 3
width = 1000 - (n * 76 + 7) * !!n
height = width * 58 / 41

Em seguida, rotacionamos e dividimos repetidamente essas dimensões para obter a subdivisão apropriada para o número de tamanho especificado.

"}"8*                         Push 1000 for later use in the width calculation.
     ~                        Read the format character from stdin.
      3%                      Convert into a number in the range 0 to 2.
        :"L"*7v               Calculate width = 1000 - (fn * 76 + 7) * !!fn
        -*!!\+<                  where fn is the format number derived above.
")"*":":                  /   Calculate height = width * 58 / 41.
                         \    Swap so the width is above the height on the stack.
                      v:&     Read the numeric size from stdin and duplicate for testing.
                      _       While not zero, go left.
                 p00-1        Decrement the size and move it from the stack into memory.
               v/             Swap the width and height.
               >2/            Divide the new width by 2.
                  00g:        Restore the size from memory and duplicate for testing.
                      _       While not zero, repeat this loop.
                       $      When zero, continue to the right and drop the size.
                        ..@   Output the width and height, then exit.