¿Qué letra del alfabeto inglés ocupa la mayoría de los píxeles?

Estoy tratando de hacer una programación dinámica basada en el número de caracteres en una oración. ¿Qué letra del alfabeto inglés ocupa la mayor cantidad de píxeles en la pantalla?

Hmm, veamos:

aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb

cccccccccccccccccccccccccccccccccccccccc

dddddddddddddddddddddddddddddddddddddddd

eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee

ffffffffffffffffffffffffffffffffffffffff

gggggggggggggggggggggggggggggggggggggggg

hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh

iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii

jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj

kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk

llllllllllllllllllllllllllllllllllllllll

mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm

nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn

oooooooooooooooooooooooooooooooooooooooo

pppppppppppppppppppppppppppppppppppppppp

qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq

rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr

ssssssssssssssssssssssssssssssssssssssss

tttttttttttttttttttttttttttttttttttttttt

uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu

vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv

wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC

DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD

EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE

FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF

GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG

HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH

IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII

JJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJ

KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK

LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL

MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM

NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN

OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO

PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP

QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ

RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR

SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS

TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT

UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU

VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV

WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ

W gana.

Por supuesto, este es un experimento empírico tonto. No hay una respuesta única a qué letra es más ancha. Depende de la fuente. Entonces tendrá que hacer un experimento empírico similar para encontrar la respuesta para su entorno. Pero el hecho es que la mayoría de las fuentes siguen las mismas convenciones, y la W mayúscula será la más amplia.

Gist con estos anchos de caracteres en forma de relación (W = 100) capturado aquí usando esta fuente de ejemplo particular:

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

Además de la respuesta increíblemente práctica de Ned Batchelder, porque vine aquí preguntándome acerca de los dígitos:

0000000000000000000000000000000000000000

1111111111111111111111111111111111111111

2222222222222222222222222222222222222222

3333333333333333333333333333333333333333

4444444444444444444444444444444444444444

5555555555555555555555555555555555555555

6666666666666666666666666666666666666666

7777777777777777777777777777777777777777

8888888888888888888888888888888888888888

9999999999999999999999999999999999999999

¿Qué tal una solución programática?

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 "M" mayúscula es convencionalmente la más amplia.

Creo que la carta Wes la más amplia.

Dependiendo de su plataforma, puede haber una forma de "getWidth" de una cadena o función DrawText () de alguna manera con una propiedad de ancho.

Haría un algoritmo simple que utilizara la fuente necesaria y luego corriera a través del alfabet y lo almacenara en una configuración pequeña o simplemente lo calculara en la inicialización como un ciclo de A a Z no es tan difícil.

También depende de la fuente. Lo hice hace 1 o 2 años con Processing y Helvetica y es ILJTYFVCPAXUZKHSEDORGNBQMW en orden de píxeles en aumento. La idea es dibujar el texto en un lienzo con la fuente que está mirando, contar los píxeles y luego ordenarlos con un HashMap o un Diccionario.

Por supuesto, esto podría no estar directamente relacionado con su uso, ya que calcula el área de píxeles en lugar del ancho. Podría ser un poco exagerado también.

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 en Chrome - W gana .

Alex Michael publicó en su blog una solución para calcular el ancho de las fuentes un poco como la solución publicada por xxx en su blog (que curiosamente me vinculó aquí).

Resumen:

• Para Helvetica, las tres primeras letras son: M (2493 píxeles), W (2414) y B (1909).
• Para un conjunto de fuentes que se entregó con su Mac, los resultados son más o menos los mismos: M (2217.51 ​​± 945.19), W (2139.06 ± 945.29) y B (1841.38 ± 685.26).

Publicación original: http://alexmic.net/letter-pixel-count/

Código:

# -*- 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()

Dependerá de la fuente. Crearía un pequeño programa en un lenguaje de programación con el que se sienta más cómodo, donde dibuje cada letra del alfabeto en un mapa de bits de tamaño m. Inicialice cada píxel con blanco. Luego cuente el número de píxeles blancos después de haber dibujado cada letra y guarde ese número. El número más alto que encuentre es el que está buscando.

EDITAR: si de hecho solo está interesado en cuál ocupa el rectángulo más grande (pero parece que realmente está después de eso, no los píxeles), puede usar varias llamadas API para encontrar el tamaño, pero eso depende de tu lenguaje de programación En Java, por ejemplo, usaría la clase FontMetrics.

Sé que la respuesta aceptada aquí es W, W es para WIN.

Sin embargo, en este caso, W también es para Ancho. El estudio de caso utilizado empleó una prueba de ancho simple para examinar los píxeles, pero fue solo el ancho, no el recuento total de píxeles. Como ejemplo de contador fácil, la respuesta aceptada supone que O y Q ocupan la misma cantidad de píxeles, pero solo ocupan la misma cantidad de espacio.

Por lo tanto, W ocupa la mayor parte del espacio . Pero, ¿son todos los píxeles que parece ser?

Obtengamos algunos datos empíricos. Creé imágenes imgur de los siguientes B, M y W. Luego analicé su recuento de píxeles (ver más abajo), aquí están los resultados:

B: 114 píxeles

M: 150 píxeles

W: 157 píxeles

Así es como los introduje en el lienzo y analicé los datos de píxeles sin procesar de las imágenes.

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>

¿Quieres saber el glifo más largo real , no solo adivinar?
Y no solo estoy hablando de letras, dígitos y símbolos comunes (!, @, Etc.). Me refiero al glifo más largo de todos los 32.834 caracteres de UTF-16.
Así que comencé con la respuesta de @NK que tenía una solución programática e hice algunas modificaciones leves :

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

Después de ejecutar esto y esperar (y esperar), da la salida ௌ won.
Y ahí lo tienes, ¡el personaje más largo de UTF-32! Tenga en cuenta que en algunas fuentes el glifo más largo es ﷽, pero las otras fuentes (especialmente las monoespaciales) se superponen a los caracteres, al igual que con la fuente que el programa tiene en cuenta.

Depende de la fuente. El cero cruzado, por ejemplo, ocupa mucho más que uno normal.

Pero si uno pudiera adivinar, iría con X o B.