Compito

Dato una lettera (A, B, C) e un numero (0-10), stampa il formato del formato carta standard corrispondente (Serie A e B) o il formato busta standard corrispondente (serie C) in millimetri nel formato aaaa x bbbbdove aaaae bbbbsono le misure di larghezza e altezza in millimetri secondo ISO216 (Serie A e B) o ISO296 (Serie C)

Per semplificare le cose citerò dalla tabella delle dimensioni della carta di 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

Quindi esempi di input e output:

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

Cose da notare:

1. Il formato "210 x 297" o "1000 x 1414" ecc. Mentre questo è il formato preferibile, puoi scegliere di omettere la "x" dal tuo output, cioè sotto forma di un array o due numeri o qualunque cosa solletica la tua fantasia purché la misura della larghezza sia emessa prima dell'altezza.
2. Il rapporto tra l'altezza e la larghezza è approssimativamente equivalente alla radice quadrata di 2, quindi nel calcolo delle altezze, la larghezza viene moltiplicata per sqrt (2), quindi arrotondata per eccesso o per difetto al millimetro più vicino, con conseguente conseguente le misure nella tabella sopra. Questo può aiutare a ridurre il codice.
3. Nelle dimensioni successive per una serie mentre scendi la tabella, la larghezza per una dimensione diventa l'altezza per la successiva. Questo può anche aiutarti a golf giù il tuo codice.

Regole:

1. Questo è code-golf. Di conseguenza si applicano le regole standard. Il punteggio si baserà sul conteggio dei byte. Vincerà il conteggio più basso.
2. Niente sciocche scappatoie , ci siamo già stati prima ... Non lo faremo di nuovo.
3. Se puoi codificarlo, ti preghiamo di considerare anche di collegare un link a un'istanza funzionante del tuo codice in modo che altri programmatori e golfisti possano imparare come funziona il tuo codice. Questo non è obbligatorio, ma vorrei incoraggiare gli altri a farlo in modo che tutti possiamo imparare gli uni dagli altri. Mi piacerebbe sicuramente imparare di più sulle altre lingue dei golfisti, ove possibile.

Buona fortuna.

JavaScript (ES7), 57 byte

Salvato 1 byte grazie 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 byte

Deve -lmfunzionare su TIO, ma funziona bene sul mio computer senza l'opzione.

Risparmiato 20 byte grazie a pizzapants184 .

Restituisce i valori tramite puntatore.

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

Spiegazione:

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 byte

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

Provalo online!

Lotto, 105 byte

@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 byte

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

Salva molti byte utilizzando un formato di output alternativo, grazie a Neil.

Java (OpenJDK 8) , 59 byte

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

Provalo online!

Ispirato alla voce C di @Colera Su , poi migliorato da solo.

• 14 byte salvati grazie a Kevin Cruijssen

MATL , 34 33 30 byte

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

Provalo online! o Verifica tutti i casi di test

Salvato 4 byte grazie a Luis Mendo

APL (Dyalog) , 31 28 byte

-2 grazie a ngn.

Corpo del programma completo. Assume ⎕IO( I NDICE O rigine) di essere 0, che è di default su molti sistemi. Richiede il numero, quindi la lettera, entrambi da STDIN. Stampa su STDOUT.

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

Provalo online!

Una versione leggermente modificata ci consente di testare tutte le possibilità contemporaneamente: provalo online!

⍳2 primi due ɩ ndices, ovvero 0 e 1

⎕- sottrarlo dall'input numerico

4× moltiplicare quattro con quello

(... )+ aggiungi quanto segue

 ⍞ inserimento caratteri ...

 'BC'⍳ ... s de ndex in questa stringa ("A" darà 2, come indice oltre l'ultimo)

8÷⍨ dividerlo per 8

2* elevare 2 al potere di quello

1E3÷ 1000 diviso per quello

.2+ aggiungi ⅕ a quello

⌊ piano (arrotondato per difetto)

Befunge, 69 56 55 byte

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

Provalo online!

Spiegazione

Non abbiamo il lusso di virgola mobile o qualcosa di simile a una funzione di potenza in Befunge, quindi calcoliamo la dimensione di base per il dato carattere di formato, f , come segue:

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

Quindi ruotiamo e dividiamo ripetutamente queste dimensioni per arrivare alla suddivisione appropriata per il numero di dimensioni specificato.

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