web-dev-qa-db-fra.com

Quelle lettre de l'alphabet anglais occupe le plus de pixels?

J'essaie de faire de la programmation dynamique en fonction du nombre de caractères d'une phrase. Quelle lettre de l'alphabet anglais occupe le plus de pixels à l'écran?

csschar
166
keruilin

Hmm, voyons:

aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb

cccccccccccccccccccccccccccccccccccccccccccccc

ddddddddddddddddddddddddddddddddddddddddddddddd

eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee

ffffffffffffffffffffffffffffffffffffffffffff

ggggggggggggggggggggggggggggggggggggggggggggg

hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh

iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii

jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj

kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk

llllllllllllllllllllllllllllllllllllllllllll

mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm

nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn

oooooooooooooooooooooooooooooooooooooooooooo

pppppppppppppppppppppppppppppppppppppppppp

qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq

rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr

ssssssssssssssssssssssssssssssssssssssssssss

tttttttttttttttttttttttttttttttttttttttttt

uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu

vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv

wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy

zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC

DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD

EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE

FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF

GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG

HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH

IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII

JJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJ

KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK

LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL

MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM

NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN

OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO

PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP

QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ

RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR

SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS

TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT

UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU

VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV

WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY

ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ

W gagne.

Bien sûr, il s’agit d’une expérience empirique stupide. Il n’existe pas de réponse unique à la lettre la plus large. Cela dépend de la police. Vous devrez donc faire une expérience empirique similaire pour trouver la réponse à votre environnement. Mais le fait est que la plupart des polices suivent les mêmes conventions et que W sera le plus large.

670
Ned Batchelder

Suite à la réponse incroyablement pratique de Ned Batchelder, parce que je suis venu ici pour me poser des questions sur les chiffres:

00000000000000000000000000000000000000000000

111111111111111111111111111111111111111111

22222222222222222222222222222222222222222222

3333333333333333333333333333333333333333

444444444444444444444444444444444444444444

55555555555555555555555555555555555555

6666666666666666666666666666666666666666

777777777777777777777777777777777777777777

8888888888888888888888888888888888888888

99999999999999999999999999999999999999

105
Earl Jenkins

Que diriez-vous d'une solution programmatique?

var capsIndex = 65;
var smallIndex = 97
var div = document.createElement('div');
div.style.float = 'left';
document.body.appendChild(div);
var highestWidth = 0;
var elem;

for(var i = capsIndex; i < capsIndex + 26; i++) {
    div.innerText = String.fromCharCode(i);
    var computedWidth = window.getComputedStyle(div, null).getPropertyValue("width");
    if(highestWidth < parseFloat(computedWidth)) {
        highestWidth = parseFloat(computedWidth);
        elem = String.fromCharCode(i);
    }
}
for(var i = smallIndex; i < smallIndex + 26; i++) {
    div.innerText = String.fromCharCode(i);
    var computedWidth = window.getComputedStyle(div, null).getPropertyValue("width");
    if(highestWidth < parseFloat(computedWidth)) {
        highestWidth = parseFloat(computedWidth);
        elem = String.fromCharCode(i);
    }
}
div.innerHTML = '<b>' + elem + '</b>' + ' won';
18
N K

Je crois que la lettre W est la plus large.

14
Tudor

Capital "M" est conventionnellement le plus large.

12
ChrisW

Arial 30px dans Chrome - W gagne.

5
Šime Vidas

Selon votre plate-forme, il peut exister un moyen de "getWidth" à partir d'une chaîne ou d'une fonction DrawText () avec une propriété width.

Je voudrais faire un simple algortime qui utilise la police nécessaire, puis parcouru l’alfabet et le stocke dans une petite configuration ou le calcule à l’initialisation sous la forme d’une boucle de A à Z n’est pas si difficile.

5
BerggreenDK

Cela dépend aussi de la police. Je l’ai fait il ya 1 ou 2 ans avec Processing et Helvetica et c’est ILJTYFVCPAXUZKHSEDORGNBQMW par ordre croissant de pixels. L'idée est de dessiner le texte sur une toile avec la police que vous regardez, compter les pixels, puis trier avec une HashMap ou un Dictionnaire.

Bien sûr, cela peut ne pas être directement lié à votre utilisation, car cela calcule la surface en pixels plutôt que la largeur. Peut-être un peu exagéré aussi.

void setup() { 
 size(30,30);
 HashMap hm = new HashMap();
 fill(255);
 PFont font = loadFont("Helvetica-20.vlw");
 textFont(font,20);
 textAlign(CENTER);

 for (int i=65; i<91; i++) {
    background(0);
    text(char(i),width/2,height-(textDescent()+textAscent())/2); 
    loadPixels();
    int white=0;
    for (int k=0; k<pixels.length; k++) {
       white+=red(pixels[k]);
    }
    hm.put(char(i),white);
  }

  HashMap sorted = getSortedMap(hm);

  String asciiString = new String();

  for (Iterator<Map.Entry> i = sorted.entrySet().iterator(); i.hasNext();) { 
    Map.Entry me = (Map.Entry)i.next();
    asciiString += me.getKey();
  }

  println(asciiString); //the string in ascending pixel order

}

public HashMap getSortedMap(HashMap hmap) {
  HashMap map = new LinkedHashMap();
  List mapKeys = new ArrayList(hmap.keySet());
  List mapValues = new ArrayList(hmap.values());

  TreeSet sortedSet = new TreeSet(mapValues);
  Object[] sortedArray = sortedSet.toArray();
  int size = sortedArray.length;

  // a) Ascending sort

  for (int i=0; i<size; i++) {
    map.put(mapKeys.get(mapValues.indexOf(sortedArray[i])), sortedArray[i]);
  }
  return map;
}
5
Kwok Pan Fung

Une solution pour calculer les largeurs de polices un peu comme la solution postée par xxx a été postée par Alex Michael sur son blog (qui m'a assez étrangement lié ici).

Résumé:

  • Pour Helvetica, les trois premières lettres sont: M (2493 pixels), W (2414) et B (1909).
  • Pour un jeu de polices fourni avec son Mac, les résultats sont à peu près les mêmes: M (2217,51 ± 945,19), W (2139,06 ± 945,29) et B (1841,38 ± 685,26).

Message original: http://alexmic.net/letter-pixel-count/

Code: 

# -*- coding: utf-8 -*-
from __future__ import division
import os
from collections import defaultdict
from math import sqrt
from PIL import Image, ImageDraw, ImageFont


# Make a lowercase + uppercase alphabet.
alphabet = 'abcdefghijklmnopqrstuvwxyz'
alphabet += ''.join(map(str.upper, alphabet))


def draw_letter(letter, font, save=True):
    img = Image.new('RGB', (100, 100), 'white')

    draw = ImageDraw.Draw(img)
    draw.text((0,0), letter, font=font, fill='#000000')

    if save:
        img.save("imgs/{}.png".format(letter), 'PNG')

    return img


def count_black_pixels(img):
    pixels = list(img.getdata())
    return len(filter(lambda rgb: sum(rgb) == 0, pixels))


def available_fonts():
    fontdir = '/Users/alex/Desktop/English'
    for root, dirs, filenames in os.walk(fontdir):
        for name in filenames:
            path = os.path.join(root, name)
            try:
                yield ImageFont.truetype(path, 100)
            except IOError:
                pass


def letter_statistics(counts):
    for letter, counts in sorted(counts.iteritems()):
        n = len(counts)
        mean = sum(counts) / n
        sd = sqrt(sum((x - mean) ** 2 for x in counts) / n)
        yield letter, mean, sd


def main():
    counts = defaultdict(list)

    for letter in alphabet:
        for font in available_fonts():
            img = draw_letter(letter, font, save=False)
            count = count_black_pixels(img)
            counts[letter].append(count)

        for letter, mean, sd in letter_statistics(counts):
            print u"{0}: {1:.2f} ± {2:.2f}".format(letter, mean, sd)


    if __== '__main__':
        main()
3
javatarz

Je sais que la réponse acceptée ici est W, W est pour WIN.

Cependant, dans ce cas, W est également pour la largeur. L'étude de cas utilisée utilisait un simple test de largeur pour examiner les pixels, mais il ne s'agissait que de la largeur, pas du nombre total de pixels. En guise d’exemple simple, la réponse acceptée suppose que O et Q occupent la même quantité de pixels, mais qu’ils occupent seulement la même quantité d’espace.

Ainsi, W occupe le plus espace. Mais, est-ce que tous les pixels sont fissurés?

Obtenons des données empiriques. J'ai créé des images imgur à partir des B, M et W suivants. J'ai ensuite analysé leur nombre de pixels (voir ci-dessous), voici les résultats:

B: 114 pixels

M: 150 pixels

W: 157 pixels

Voici comment je les ai introduits dans la toile et analysé les données de pixels brutes des images.

var imgs = {
 B : "//i.imgur.com/YOuEPOn.png",
 M : "//i.imgur.com/Aev3ZKQ.png",
 W : "//i.imgur.com/xSUwE7w.png"
};
window.onload = function(){
  for(var key in imgs){(function(img,key){
    var Out = document.querySelector("#"+key+"Out");
    img.crossOrigin = "Anonymous";
    img.src=imgs[key];
    img.onload = function() {
      var canvas = document.querySelector('#'+key);
      (canvas.width = img.width,canvas.height = img.height);
      var context = canvas.getContext('2d');
      context.drawImage(img, 0, 0);
      var data = context.getImageData(0, 0, img.width, img.height).data;
      Out.innerHTML = "Total Pixels: " + data.length/4 + "<br>";
      var pixelObject = {};
      for(var i = 0; i < data.length; i += 4){
        var rgba = "rgba("+data[i]+","+data[i+1]+","+data[i+2]+","+data[i+3]+")";
       pixelObject[rgba] = pixelObject[rgba] ? pixelObject[rgba]+1 : 1;
      }
      Out.innerHTML += "Total Whitespace: " + pixelObject["rgba(255,255,255,255)"] + "<br>";
      Out.innerHTML += "Total Pixels In "+ key +": " + ((data.length/4)-pixelObject["rgba(255,255,255,255)"]) + "<br>";
    };
  })(new Image(),key)}
};
<table>
<tr>
  <td>
    <canvas id="B" width="100%" height="100%"></canvas>
  </td>
  <td id="BOut">
  </td>
</tr>
<tr>
  <td>
    <canvas id="M" width="100%" height="100%"></canvas>
  </td>
  <td id="MOut">
  </td>
</tr>
<tr>
  <td>
    <canvas id="W" width="100%" height="100%"></canvas>
  </td>
  <td id="WOut">
  </td>
</tr>
</table>
1
Travis J

Cela dépendra de la police. Je créerais un petit programme dans un langage de programmation avec lequel vous êtes le plus à l'aise, dans lequel vous tracez chaque lettre de l'alphabet en un bitmap de taille m. Initialisez chaque pixel avec du blanc. Puis comptez le nombre de pixels blancs après avoir dessiné chaque lettre et enregistrez ce nombre. Le nombre le plus élevé que vous trouvez est celui que vous recherchez.

EDIT: Si vous voulez savoir quel est le plus grand rectangle (mais on dirait que c’est vraiment après cela, pas les pixels), vous pouvez utiliser divers appels d’API pour trouver la taille, mais cela dépend votre langage de programmation. En Java, par exemple, vous utiliseriez la classe FontMetrics.

1
steinar

Cela dépend de la police. Le zéro croisé, par exemple, prend beaucoup plus que le normal.

Mais si on pouvait deviner, j'irais avec X ou B.

0
Rook