Welcher Buchstabe des englischen Alphabets nimmt die meisten Pixel ein?

Ich versuche, eine dynamische Programmierung basierend auf der Anzahl der Zeichen in einem Satz durchzuführen. Welcher Buchstabe des englischen Alphabets nimmt die meisten Pixel auf dem Bildschirm ein?

Hmm, mal sehen:

aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb

cccccccccccccccccccccccccccccccccccccccccc

ddddddddddddddddddddddddddddddddddddddddd

eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee

fffffffffffffffffffffffffffffffffffffffff

ggggggggggggggggggggggggggggggggggggggggg

hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh

iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii

jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj

kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk

llllllllllllllllllllllllllllllllllllllllll

mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm

nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn

oooooooooooooooooooooooooooooooooooooooo

ppppppppppppppppppppppppppppppppppppppppp

qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq

rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr

ssssssssssssssssssssssssssssssssssssssss

ttttttttttttttttttttttttttttttttttttttttttt

uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu

vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv

wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy

zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC

DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD

EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE

FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF

GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG

HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH

IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII

JJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJ

KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK

LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL

MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM

NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN

OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO

PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP

QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ

RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR

SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS

TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT

UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU

VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV

WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

JJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJ

ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ

W gewinnt.

Dies ist natürlich ein dummes empirisches Experiment. Es gibt keine einzige Antwort darauf, welcher Buchstabe am breitesten ist. Das hängt von der Schriftart ab. Sie müssen also ein ähnliches empirisches Experiment durchführen, um die Antwort für Ihre Umgebung herauszufinden. Tatsache ist jedoch, dass die meisten Schriftarten denselben Konventionen folgen und das Großbuchstabe W am breitesten ist.

Geben Sie diese Zeichenbreiten in einer Verhältnisform (W = 100) an, die hier mit dieser speziellen Beispielschriftart erfasst wurde:

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

Weiter zu Ned Batchelders unglaublich praktischer Antwort, weil ich hierher gekommen bin und mich über Ziffern gewundert habe:

000000000000000000000000000000000000000000

11111111111111111111111111111111111111111111

2222222222222222222222222222222222222222

33333333333333333333333333333333333333333333

444444444444444444444444444444444444444444

555555555555555555555555555555555555555555

666666666666666666666666666666666666666666

7777777777777777777777777777777777777777

888888888888888888888888888888888888888888

999999999999999999999999999999999999999999

Wie wäre es mit einer programmatischen Lösung?

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

Das Kapital "M" ist herkömmlicherweise das breiteste.

Ich glaube, der Brief Wist der breiteste.

Abhängig von Ihrer Plattform gibt es möglicherweise eine Möglichkeit, "getWidth" von einem String oder einer DrawText () -Funktion mit einer width-Eigenschaft zu erhalten.

Ich würde eine einfache Algortime erstellen, die die benötigte Schriftart verwendet und dann das Alfabet durchläuft und es in einer kleinen Konfiguration speichert oder es einfach bei der Initialisierung berechnet, da eine Schleife von A nach Z nicht so schwer ist.

Dies hängt auch von der Schriftart ab. Ich habe dies vor 1 oder 2 Jahren mit Processing und Helvetica gemacht und es ist ILJTYFVCPAXUZKHSEDORGNBQMW in der Reihenfolge zunehmender Pixel. Die Idee ist, den Text mit der Schriftart, die Sie betrachten, auf eine Leinwand zu zeichnen, die Pixel zu zählen und dann mit einer HashMap oder einem Wörterbuch zu sortieren.

Dies ist natürlich möglicherweise nicht direkt relevant für Ihre Verwendung, da hierdurch die Pixelfläche und nicht nur die Breite berechnet wird. Könnte auch ein wenig übertrieben sein.

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 in Chrome - W gewinnt .

Eine Lösung, um die Breite von Schriftarten ein wenig wie die von xxx veröffentlichte Lösung zu berechnen, wurde von Alex Michael in seinem Blog veröffentlicht (der mich lustigerweise hier verlinkt hat).

Zusammenfassung:

• Für Helvetica sind die drei obersten Buchstaben: M (2493 Pixel), W (2414) und B (1909).
• Für eine Reihe von Schriftarten, die mit seinem Mac geliefert wurden, sind die Ergebnisse mehr oder weniger gleich: M (2217,51 ± 945,19), W (2139,06 ± 945,29) und B (1841,38 ± 685,26).

Ursprünglicher Beitrag: 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()

Dies hängt von der Schriftart ab. Ich würde ein kleines Programm in einer Programmiersprache erstellen, mit der Sie am besten vertraut sind, wobei Sie jeden Buchstaben des Alphabets in eine Bitmap mit einer Größe von m m zeichnen. Initialisieren Sie jedes Pixel mit Weiß. Zählen Sie dann die Anzahl der weißen Pixel, nachdem Sie jeden Buchstaben gezeichnet haben, und speichern Sie diese Anzahl. Die höchste Zahl, die Sie finden, ist die, die Sie suchen.

BEARBEITEN: Wenn Sie tatsächlich nur daran interessiert sind, welches das größte Rechteck einnimmt (aber es sieht so aus, als wären Sie wirklich danach, nicht die Pixel), können Sie verschiedene API-Aufrufe verwenden, um die Größe zu ermitteln, aber das hängt davon ab Ihre Programmiersprache. In Java würden Sie beispielsweise die FontMetrics-Klasse verwenden.

Ich weiß, dass die akzeptierte Antwort hier W ist, W ist für WIN.

In diesem Fall steht W jedoch auch für Breite. In der verwendeten Fallstudie wurde ein einfacher Breitentest verwendet, um Pixel zu untersuchen, aber es war nur die Breite, nicht die Gesamtpixelzahl. Als einfaches Gegenbeispiel wird in der akzeptierten Antwort davon ausgegangen, dass O und Q dieselbe Pixelmenge einnehmen, jedoch nur dieselbe Menge an Speicherplatz.

Somit nimmt W den meisten Platz ein . Aber sind es all die Pixel, die es zu sein gilt?

Lassen Sie uns einige empirische Daten erhalten. Ich habe Bilder aus den folgenden B, M und W erstellt. Anschließend habe ich ihre Pixelanzahl analysiert (siehe unten). Hier sind die Ergebnisse:

B: 114 Pixel

M: 150 Pixel

W: 157 Pixel

Hier ist, wie ich sie in Leinwand eingezogen und die Rohpixeldaten aus den Bildern analysiert habe.

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>

Möchten Sie die wirklich längste Glyphe kennen und nicht nur raten?
Und ich spreche nicht nur über die Buchstaben, Ziffern und allgemeinen Symbole (!, @ Usw.). Ich meine die längste Glyphe in allen 32.834 Zeichen von UTF-16.
Also begann ich mit einer Antwort von @NK, die eine programmatische Lösung hatte, und nahm einige geringfügige Änderungen daran vor:

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

Nachdem dies ausgeführt und gewartet (und gewartet) wurde, wird die Ausgabe ausgegeben ௌ won.
Und da haben Sie es, den längsten Charakter in UTF-32! Beachten Sie, dass bei einigen Schriftarten das längste Symbol ﷽ ist, die anderen Schriftarten (insbesondere Monospace-Schriftarten) jedoch die Zeichen überlappen, wie bei der Schriftart, die das Programm vom Programm berücksichtigt.

Das hängt von der Schriftart ab. Eine gekreuzte Null nimmt beispielsweise erheblich mehr ein als eine reguläre Eins.

Aber wenn man eine Vermutung anstellen könnte, würde ich mit X oder B gehen.