Tarea

Dada una letra (A, B, C) y un número (0-10), imprima el tamaño del tamaño de papel estándar correspondiente (Serie A y B) o el tamaño de sobre estándar correspondiente (serie C) en milímetros en el formato aaaa x bbbbdonde aaaay bbbbson las medidas de ancho y alto en milímetros según ISO216 (Serie A y B) o ISO296 (Serie C)

Para facilitar las cosas, citaré de la tabla de tamaños de papel de 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

Entonces ejemplos de entrada y salida:

**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

Cosas a tener en cuenta:

1. El formato "210 x 297" o "1000 x 1414", etc. Si bien este es el formato preferible, puede optar por omitir la "x" de su salida, es decir, en forma de una matriz o dos números o lo que más le guste. siempre que la medida del ancho se emita antes que la altura.
2. La relación entre la altura y el ancho es aproximadamente equivalente a la raíz cuadrada de 2, por lo que en el cálculo de las alturas, el ancho se multiplica por sqrt (2), y luego se redondea hacia arriba o hacia abajo al milímetro más cercano, lo que resulta en las medidas en la tabla de arriba. Esto puede ayudar a jugar golf en tu código.
3. En tamaños sucesivos para una serie a medida que baja de la tabla, el ancho de un tamaño se convierte en la altura del siguiente. Esto también puede ayudarlo a descifrar su código.

Reglas:

1. Este es el código de golf. Las reglas estándar se aplican como resultado. La puntuación se basará en el recuento de bytes. El conteo más bajo ganará.
2. No hay escapatorias tontas , hemos estado allí antes ... No vamos a pasar por esto otra vez.
3. Si puede codificarlo, considere adjuntar un enlace a una instancia de trabajo de su código para que otros programadores y golfistas puedan aprender cómo funciona su código. Esto no es obligatorio, pero me gustaría animar a otros a hacer esto para que todos podamos aprender unos de otros. Ciertamente me encantaría aprender más sobre los idiomas de otros golfistas cuando sea posible.

La mejor de las suertes.

JavaScript (ES7), 57 bytes

Guardado 1 byte gracias 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

Necesita -lmejecutarse en TIO, pero funciona bien en mi computadora sin la opción.

Ahorró 20 bytes gracias a pizzapants184 .

Valores de retorno por puntero.

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

Explicación:

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;
}

Pitón 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

Pruébalo en línea!

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``);

Ahorre muchos bytes utilizando un formato de salida alternativo, gracias a Neil.

Java (OpenJDK 8) , 59 bytes

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

Pruébalo en línea!

Inspirado en la entrada C de @Colera Su , luego mejorado por mí mismo.

• 14 bytes guardados gracias a Kevin Cruijssen

MATL , 34 33 30 bytes

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

Pruébalo en línea! o Verificar todos los casos de prueba

Guardado 4 bytes gracias a Luis Mendo

APL (Dyalog) , 31 28 bytes

-2 gracias a ngn.

Programa completo del cuerpo. Asume ⎕IO( I ndex O rigin) ser 0, que es predeterminado en muchos sistemas. Solicita número, luego letra, ambos de STDIN. Imprime en STDOUT.

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

Pruébalo en línea!

Una versión ligeramente modificada nos permite probar todas las posibilidades a la vez: ¡ Pruébelo en línea!

⍳2 dos primeros ɩ nices, es decir, 0 y 1

⎕- restar eso de la entrada numérica

4× multiplica cuatro por eso

(... )+ agregue lo siguiente

 ⍞ entrada de caracteres ...

 'BC'⍳ ... 's ɩ ɩ de esta cadena ("A" dará 2, como el índice más allá del último)

8÷⍨ dividir eso por 8

2* elevar 2 al poder de eso

1E3÷ 1000 dividido por eso

.2+ agregue ⅕ a eso

⌊ piso (redondear hacia abajo)

Befunge, 69 56 55 bytes

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

Pruébalo en línea!

Explicación

No tenemos el lujo de coma flotante ni nada parecido a una función de potencia en Befunge, por lo que calculamos el tamaño base para el carácter de formato dado, f , de la siguiente manera:

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

Luego rotamos y dividimos repetidamente estas dimensiones para llegar a la subdivisión apropiada para el número de tamaño dado.

"}"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.