Która litera alfabetu angielskiego zajmuje najwięcej pikseli?

Dalej do niesamowicie praktycznej odpowiedzi Neda Batcheldera, ponieważ przyszedłem tutaj zastanawiając się nad cyframi:

0000000000000000000000000000000000000000

1111111111111111111111111111111111111111

2222222222222222222222222222222222222222

3333333333333333333333333333333333333333

4444444444444444444444444444444444444444

5555555555555555555555555555555555555555

6666666666666666666666666666666666666666

7777777777777777777777777777777777777777

8888888888888888888888888888888888888888

9999999999999999999999999999999999999999

Myślę, że litera {[0] } jest najszersza.

Duże " M " jest umownie najszersze.

A co z rozwiązaniem programowym?

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

W zależności od platformy może istnieć sposób na "getWidth" z funkcji string lub DrawText() z właściwością width.

Stworzyłbym prosty algorytm, który wykorzystywał potrzebną czcionkę, a następnie przebiegał przez alfabet i przechowywał go w małej konfiguracji lub po prostu obliczał go przy inicjalizacji jako pętlę od A do Z nie jest tak trudne.

To również zależy od czcionki. Zrobiłem to 1 lub 2 lata temu z przetwarzaniem i Helvetica i jest to ILJTYFVCPAXUZKHSEDORGNBQMW w kolejności zwiększania pikseli. Chodzi o to, aby narysować tekst na płótnie za pomocą czcionki, na którą patrzysz, policzyć piksele, a następnie posortować za pomocą Hashmapy lub słownika.

Oczywiście może to nie być bezpośrednio związane z używaniem, ponieważ oblicza obszar pikseli, a nie tylko szerokość. To też może być przesada.

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 w Chrome- W wins .

Rozwiązanie do obliczania szerokości czcionek trochę jak rozwiązanie opublikowane przez xxx zostało opublikowane przez Alexa Michaela na jego blogu(który śmiesznie mnie tutaj linkował).

Podsumowanie:

• dla Helvetiki trzy pierwsze litery to: M (2493 piksele), W (2414) i B (1909).
• dla zestawu czcionek dostarczanych z jego komputerem Mac, wyniki są mniej więcej takie same: M (2217,51 ± 945,19), W (2139,06 ± 945,29) i B (1841,38 ± 685,26).

Oryginał Post: http://alexmic.net/letter-pixel-count/

Kod:

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

To zależy od czcionki. Chciałbym stworzyć mały program w języku programowania, z którym jesteś najbardziej komfortowe, gdzie można rysować każdą literę alfabetu W N razy m wielkości bitmapy. Zainicjalizuj każdy piksel kolorem białym. Następnie policz liczbę białych pikseli po narysowaniu każdej litery i zapisz tę liczbę. Najwyższa liczba, którą znajdziesz, to ta, której szukasz.

EDIT: jeśli interesuje Cię tylko, który z nich zajmuje największy prostokąt (ale wygląda to tak jesteś naprawdę po to, nie pikseli), można użyć różnych wywołań API, aby znaleźć rozmiar, ale to zależy od języka programowania. Na przykład w Javie można użyć klasy FontMetrics.

Wiem, że akceptowana odpowiedź brzmi W, W jak wygrana.

Jednak W tym przypadku W oznacza również szerokość. Zastosowane studium przypadku wykorzystało prosty test szerokości do zbadania pikseli, ale była to tylko szerokość, a nie całkowita liczba pikseli. Jako łatwy przykład licznika, przyjęta odpowiedź zakłada, że O I Q zajmują tę samą ilość pikseli, ale zajmują tylko tę samą ilość miejsca.

W ten sposób W zajmuje najwięcejprzestrzeni . Ale czy to wszystkie piksele, do których jest popękane być?

B : 114 pikseli

M : 150 pikseli

W : 157 pikseli

Oto jak wprowadziłem je na płótno i przeanalizowałem surowe dane pikseli z obrazów.

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>

To zależy od czcionki. Na przykład przekroczenie zera zajmuje znacznie więcej niż zwykłe.

Ale gdyby ktoś mógł zgadnąć, wybrałbym X lub B.