À l'époque, les composeurs automatiques de téléphone utilisaient des cartes perforées avec une colonne pour chaque chiffre du numéro à composer. Les colonnes avaient sept rangées. Les trois premières lignes représentaient les nombres (1,2,3), (4,5,6) et (7,8,9) respectivement. Les trois dernières rangées ont fait pivoter cet arrangement de 90 °: (1,4,7), (2,5,8) et (3,6,9). La rangée du milieu a été utilisée pour 0. Tout chiffre 1-9 aurait deux trous perforés - un dans les trois premières rangées et un dans les trois rangées inférieures. Zéro aurait seulement frappé la rangée du milieu. Visualisons la colonne poinçonnée pour le numéro 6 ( .non xpoinçonnée, poinçonnée, le guide à gauche est juste pour illustrer l'encodage):

123 .
456 x
789 .
 0  .
147 .
258 .
369 x

Nous recherchons quelles lignes contiennent le numéro que nous essayons de composer. Pour 6, il s'agit de la deuxième rangée et de la neuvième rangée. Ces deux lignes sont perforées, les cinq lignes restantes ne sont pas perforées. Voici les motifs perforés pour tous les chiffres de 0 à 9:

    0 1 2 3 4 5 6 7 8 9
123 . x x x . . . . . .
456 . . . . x x x . . .
789 . . . . . . . x x x
 0  x . . . . . . . . .
147 . x . . x . . x . .
258 . . x . . x . . x .
369 . . . x . . x . . x

Votre objectif est de (écrire un programme ou une fonction pour) perforer ces cartes pour moi.

Entrée: Un nombre, pris dans n'importe quel format raisonnable (chaîne, entier, liste d'entiers, etc.), ne dépassant pas 9999999999999.

Sortie: La grille de colonnes perforées correspondant à l'entrée numérique. Vous n'avez pas besoin des en-têtes ou de l'espacement supplémentaire indiqués ci-dessus, juste des colonnes perforées elles-mêmes. Les sauts de ligne de début / fin sont corrects, tout comme les espaces entre les lignes / colonnes tant qu'ils sont cohérents . En parlant de cela, tant qu'ils sont cohérents, vous pouvez utiliser n'importe quel caractère (non blanc) pour le poinçonnage et tout autre caractère pour le non-poinçonnage (alors que cela devrait être évident, veuillez spécifier les caractères que vous utilisez).

C'est le code-golf, donc le code le plus court l'emporte. Les failles standard ne sont pas autorisées.

Cas de test (tous utilisés .pour non perforé, xpour perforé):

In: 911
Out: .xx
     ...
     x..
     ...
     .xx
     ...
     x..

In: 8675309
Out: ....x..
     .x.x...
     x.x...x
     .....x.
     ..x....
     x..x...
     .x..x.x

In: 5553226
Out: ...xxx.
     xxx...x
     .......
     .......
     .......
     xxx.xx.
     ...x..x

Gelée , 13 octets

9s3,Z$j0ċþDZY

Essayez-le en ligne!

1= perforé, 0= non perforé.

Pyth, 25 octets

.tm?djNmX*3NkZ.Dtd3X*7N3Z

Utilise 0pour poinçonné et non "poinçonné.
Essayez-le ici

Explication

.tm?djNmX*3NkZ.Dtd3X*7N3Z
  m                      Q  For each number in the (implicit) input...
   ?d                       ... if the number is nonzero...
              .Dtd3         ... get (n - 1) divmod 3...
       mX*3NkZ              ... replace each position in `"""` with `0`...
     jN                     ... and stick them together with `"`. ...
                   X*7N3Z   ... Otherwise, `"""0"""`.
.t                          Transpose the result.

JavaScript (ES6), 60 54 octets

Prend l'entrée comme un tableau d'entiers. Renvoie une matrice binaire, avec 0 = non perforé / 1 = perforé.

a=>[14,112,896,1,146,292,584].map(n=>a.map(i=>n>>i&1))

Essayez-le en ligne!

05AB1E , 16 15 octets

Utilise 0 et 1 .

ε9ÝÀ3ôD¨ø«¢O}ø»

Essayez-le en ligne!

Explication

ε           }     # apply to each digit in input                
 9Ý               # push the range [0 ... 9]
   À              # rotate left
    3ô            # split into pieces of 3
      D¨          # duplicate and remove the last digit (0)
        ø         # transpose
         «        # append
          ¢O      # sum the counts of each in the current digit     
             ø    # transpose
              »   # format output

SOGL V0.12 , 23 octets

,{r"ΧL→▓lφ℮o¤κ²‘7nwι}⁰H

Essayez-le ici!

Compression.

Python 2 , 84 octets

lambda a:[''.join(`(ord('(1Aa2Bb4Dd'[int(n)])-32)>>k&1`for n in a)for k in range(7)]

Essayez-le en ligne!

0/1 est utilisé pour non perforé / perforé.

Python 3 , 84 80 octets

def f(s):[print(*[int(i in[~-n//3,6--n%3-3*(n<1)])for n in s])for i in range(7)]

Essayez-le en ligne!

C (bruit) , 108 107 bytes

c,i;f(*q){char*r;for(i=~0;i++<6;puts(""))for(r=q;c=*r++;c-=48,putchar(".X"[(c--?16<<c%3|1<<c/3:8)>>i&1]));}

Essayez-le en ligne!

Prend le numéro d'entrée comme chaîne. Imprime la sortie dans .et Xcomme dans les exemples.

Crédits

-1 octet merci @ ASCII uniquement

J , 31 20 octets

-11 octets grâce à FrownyFrog!

(e."1],0,|:)1+i.@3 3

Essayez-le en ligne!

J , 31 octets

1*@|:@:#.(a,0,|:a=.1+i.3 3)=/~]

Essayez-le en ligne!

Prend l'entrée comme une liste de chiffres

0 - non perforé, 1 - perforé

Explication:

   a=.1+i.3 3 - generates the matrix and stores it into a
1 2 3
4 5 6
7 8 9

   (a,0,|:a=.1+i.3 3) - generates the entire comparison table 
1 2 3
4 5 6
7 8 9
0 0 0
1 4 7
2 5 8
3 6 9

   ]=/ - creates an equality table between the input and the comparison table

 ((a,0,|:a=.1+i.3 3)=/~]) 9 1 1
0 0 0
0 0 0
0 0 1
0 0 0
0 0 0
0 0 0
0 0 1

1 0 0
0 0 0
0 0 0
0 0 0
1 0 0
0 0 0
0 0 0

1 0 0
0 0 0
0 0 0
0 0 0
1 0 0
0 0 0
0 0 0

  1*@|:@:#. - adds the tables, transposes the resulting table and finds the magnitude

  (1*@|:@:#.(a,0,|:a=.1+i.3 3)=/~])  9 1 1
0 1 1
0 0 0
1 0 0
0 0 0
0 1 1
0 0 0
1 0 0

Toile , 27 25 octets

｛９＋├３÷ｕ４％ ×#＋#¹╷３％５＋１╋］↶↕

Essayez-le ici!

Fusain , 28 octets

Ｅ⁴⭆θＩ⁼ι÷﹪⊖λχ³Ｅ³⭆θＩ∧Ｉλ¬﹪⁻⊖λι³

Essayez-le en ligne! Le lien est vers la version détaillée du code. Utilise 0/1, mais peut prendre en charge des caractères arbitraires au coût de 1 octet: Essayez-le en ligne! . Explication:

Ｅ⁴              Loop from 0 to 3
  ⭆θ            Loop over input string and join
           λ     Current character
         ⊖      Cast to integer and decrement
        ﹪  χ    Modulo predefined variable 10 (changes -1 to 9)
       ÷    ³   Integer divide by literal 3
     ⁼ι         Compare to outer loop variable
    Ｉ           Cast to string
                Implicitly print each outer result on a separate line

Ｅ³              Loop from 0 to 2
  ⭆θ            Loop over input string and join
            λ   Current character
           ⊖    Cast to integer and decrement
          ⁻  ι  Subtract outer loop variable
         ﹪    ³ Modulo by literal 3
        ¬       Logical not
       λ        Inner loop character
      Ｉ         Cast to integer
     ∧          Logical and
    Ｉ           Cast to string
                Implicitly print each outer result on a separate line

Perl 5 -F , 52 octets

for$i(123,456,789,0,147,258,369){say map$i=~$_|0,@F}

Essayez-le en ligne!

Utilise 1pour poinçonné et non 0poinçonné.