Tâche

Étant donné une lettre (A, B, C) et un nombre (0-10), sortez le format du papier standard correspondant (séries A et B) ou le format d'enveloppe standard correspondant (série C) en millimètres au format aaaa x bbbboù aaaaet bbbbsont les mesures de largeur et de hauteur en millimètres selon ISO216 (séries A et B) ou ISO296 (séries C)

Pour rendre les choses plus faciles, je vais citer le tableau des tailles de papier 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

Voici donc des exemples d'entrée et de sortie:

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

A noter:

1. Le format "210 x 297" ou "1000 x 1414" etc. Bien que ce soit le format préférable, vous pouvez choisir d'omettre le "x" de votre sortie, c'est-à-dire sous la forme d'un tableau ou de deux nombres ou tout ce qui chatouille votre fantaisie tant que la mesure de largeur est sortie avant la hauteur.
2. Le rapport entre la hauteur et la largeur est à peu près équivalent à la racine carrée de 2, donc dans le calcul des hauteurs, la largeur est multipliée par sqrt (2), puis arrondie vers le haut ou vers le bas au millimètre près, résultant ainsi en les mesures dans le tableau ci-dessus. Cela peut aider à jouer au golf avec votre code.
3. Dans les tailles successives d'une série au fur et à mesure que vous descendez le tableau, la largeur d'une taille devient la hauteur de la suivante. Cela peut également vous aider à jouer avec votre code.

Règles:

1. C'est du code-golf. Les règles standard s'appliquent en conséquence. Le score sera basé sur le nombre d'octets. Le plus petit nombre gagnera.
2. Pas de failles idiotes , nous y sommes déjà allés ... Nous ne reverrons pas ça.
3. Si vous pouvez le coder, veuillez également envisager d'attacher un lien à une instance de travail de votre code afin que d'autres programmeurs et golfeurs puissent apprendre comment fonctionne votre code. Ce n'est pas obligatoire, mais j'aimerais encourager les autres à le faire afin que nous puissions tous apprendre les uns des autres. J'aimerais certainement en savoir plus sur les langues des autres golfeurs lorsque cela est possible.

Bonne chance.

JavaScript (ES7), 57 octets

1 octet enregistré grâce à @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 octets

Il doit -lmfonctionner sur TIO, mais fonctionne bien sur mon ordinateur sans option.

Économisé 20 octets grâce aux pizzapants184 .

Renvoie des valeurs par pointeur.

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

Explication:

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 octets

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

Essayez-le en ligne!

Lot, 105 octets

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

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

Économisez de nombreux octets en utilisant un format de sortie alternatif, grâce à Neil.

Java (OpenJDK 8) , 59 octets

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

Essayez-le en ligne!

Inspiré par l'entrée C de @Colera Su , puis amélioré par moi-même.

• 14 octets économisés grâce à Kevin Cruijssen

MATL , 34 33 30 octets

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

Essayez-le en ligne! ou vérifier tous les cas de test

Enregistré 4 octets grâce à Luis Mendo

APL (Dyalog) , 31 28 octets

-2 grâce à ngn.

Corps de programme complet. Suppose que ⎕IO( I ndex O rigin) est 0, ce qui est le cas par défaut sur de nombreux systèmes. Demande le numéro, puis la lettre, tous deux de STDIN. Imprime vers STDOUT.

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

Essayez-le en ligne!

Une version légèrement modifiée nous permet de tester toutes les possibilités à la fois: Essayez-le en ligne!

⍳2 deux premiers ɩ ndices, soit 0 et 1

⎕- soustraire cela de la saisie numérique

4× multiplier quatre avec ça

(… )+ Ajoutez ce qui suit

 ⍞ saisie de caractères…

 'BC'⍳ … Est ɩ ndex dans cette chaîne ("A" donnera 2, comme l'index au-delà du dernier)

8÷⍨ divisez cela par 8

2* élever 2 à la puissance de cette

1E3÷ 1000 divisé par cela

.2+ ajouter ⅕ à cela

⌊ étage (arrondi)

Befunge, 69 56 55 octets

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

Essayez-le en ligne!

Explication

Nous n'avons pas le luxe de virgule flottante ou quelque chose comme une fonction de puissance dans Befunge, nous calculons donc la taille de base pour le caractère de format donné, f , comme suit:

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

Nous faisons ensuite tourner et diviser ces dimensions à plusieurs reprises pour arriver à la subdivision appropriée pour le numéro de taille donné.

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