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

J'essaye de faire une programmation dynamique basée sur le nombre de caractères dans une phrase. Quelle lettre de l'alphabet anglais occupe le plus de pixels à l'écran?

Hmm, voyons:

aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb

cccccccccccccccccccccccccccccccccccccc

ddddddddddddddddddddddddddddddddddddddd

eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee

ffffffffffffffffffffffffffffffffffffffff

gggggggggggggggggggggggggggggggggggggggg

hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh

iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii

jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj

kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk

llllllllllllllllllllllllllllllllllllll

mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm

nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn

oooooooooooooooooooooooooooooooooooooooo

pppppppppppppppppppppppppppppppppppppppp

qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq

rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr

ssssssssssssssssssssssssssssssssssssssssss

tttttttttttttttttttttttttttttttttttttttttt

uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu

vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv

wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy

zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC

DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD

EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE

FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF

GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG

HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH

IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII

JJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJ

KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK

LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL

MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM

NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN

OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO

PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP

QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ

RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR

SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS

TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT

UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU

VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV

WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY

ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ

W gagne.

Bien sûr, c'est une expérience empirique idiote. Il n'y a 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 pour votre environnement. Mais le fait est que la plupart des polices suivent les mêmes conventions et que la majuscule W sera la plus large.

Gist avec ces largeurs de caractères sous une forme de rapport (W = 100) capturé ici en utilisant cet exemple de police particulier:

https://gist.github.com/imaurer/d330e68e70180c985b380f25e195b90c

Suite à la réponse incroyablement pratique de Ned Batchelder, car je suis venu ici m'interroger sur les chiffres:

0000000000000000000000000000000000000000

1111111111111111111111111111111111111111

22222222222222222222222222222222222222

3333333333333333333333333333333333333333

44444444444444444444444444444444444444

55555555555555555555555555555555555555

66666666666666666666666666666666666666

77777777777777777777777777777777777777

88888888888888888888888888888888888888

99999999999999999999999999999999999999

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

La capitale "M" est classiquement la plus large.

Je pense que la lettre West la plus large.

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

Je ferais un simple algortime qui utilisait la police nécessaire, puis parcourait l'alfabet et le stockait dans une petite configuration ou le calculais simplement à l'initialisation comme une boucle de A à Z n'est pas si difficile.

Cela dépend également de la police. J'ai fait cela il y a 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, de compter les pixels, puis de trier avec un HashMap ou un dictionnaire.

Bien sûr, cela peut ne pas être directement pertinent pour votre utilisation car cela calcule la zone de 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;
}

Arial 30px dans Chrome - W gagne .

Une solution pour calculer les largeurs de polices un peu à la manière de la solution postée par xxx a été postée par Alex Michael sur son blog (qui m'a assez curieusement 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 livré avec son Mac, les résultats sont plus ou moins 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 __name__ == '__main__':
        main()

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, où vous dessinez chaque lettre de l'alphabet dans une image bitmap de taille multipliée par m. Initialisez chaque pixel avec du blanc. Ensuite, 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 en fait vous êtes simplement intéressé par celui qui occupe le plus grand rectangle (mais il semble que vous êtes vraiment après cela, pas les pixels), vous pouvez utiliser divers appels d'API pour trouver la taille, mais cela dépend de votre langage de programmation. En Java, par exemple, vous utiliseriez la classe FontMetrics.

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 a utilisé un test de largeur simple pour examiner les pixels, mais il s'agissait uniquement de la largeur et non du nombre total de pixels. À titre d'exemple de compteur simple, la réponse acceptée suppose que O et Q occupent la même quantité de pixels, mais n'occupent que la même quantité d'espace.

Ainsi, W occupe le plus d' espace . Mais, est-ce tous les pixels pour lesquels il est craqué?

Obtenons quelques 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>

Vous voulez connaître le vrai plus long glyphe, pas seulement deviner?
Et je ne parle pas seulement des lettres, des chiffres et des symboles communs (!, @ Et ainsi de suite). Je veux dire le glyphe le plus long de tous les 32 834 caractères de UTF-16.
J'ai donc commencé avec une réponse de @NK qui avait une solution programmatique, et j'y ai apporté quelques légères modifications:

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 < 32834; 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';

Après avoir exécuté ceci et attendu (et attendu), il donne la sortie ௌ won.
Et voilà, le personnage le plus long de l'UTF-32! Notez que sur certaines polices, le glyphe le plus long est ﷽, mais les autres polices (en particulier celles à espacement fixe) chevauchent les caractères, comme avec la police que le programme prend en compte dans le programme.

Cela dépend de la police. Le zéro croisé, par exemple, occupe beaucoup plus qu'un simple.

Mais si on pouvait faire une supposition, j'irais avec X ou B.