Quale lettera dell'alfabeto inglese occupa la maggior parte dei pixel?

Sto provando a fare una programmazione dinamica basata sul numero di caratteri in una frase. Quale lettera dell'alfabeto inglese occupa la maggior parte dei pixel sullo schermo?

Hmm, vediamo:

aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb

cccccccccccccccccccccccccccccccccccccccc

dddddddddddddddddddddddddddddddddddddddd

eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee

ffffffffffffffffffffffffffffffffffffffff

gggggggggggggggggggggggggggggggggggggggg

hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh

iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii

jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj

kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk

llllllllllllllllllllllllllllllllllllllll

mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm

nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn

oooooooooooooooooooooooooooooooooooooooo

pppppppppppppppppppppppppppppppppppppppp

qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq

rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr

ssssssssssssssssssssssssssssssssssssssss

tttttttttttttttttttttttttttttttttttttttt

uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu

vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv

wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy

zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC

DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD

EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE

FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF

GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG

HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH

IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII

JJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJ

KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK

LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL

MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM

NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN

OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO

PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP

QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ

RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR

SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS

TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT

UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU

VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV

WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY

ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ

V vince.

Certo, questo è un esperimento empirico sciocco. Non esiste una risposta unica a quale lettera è più ampia. Dipende dal carattere. Quindi dovrai fare un esperimento empirico simile per capire la risposta per il tuo ambiente. Ma il fatto è che la maggior parte dei caratteri segue le stesse convenzioni e la W maiuscola sarà la più ampia.

Riempi con queste larghezze di carattere in una forma di rapporto (W = 100) catturata qui usando questo particolare font di esempio:

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

Oltre alla risposta incredibilmente pratica di Ned Batchelder, perché sono venuto qui chiedendomi delle cifre:

0000000000000000000000000000000000000000

1111111111111111111111111111111111111111

2222222222222222222222222222222222222222

3333333333333333333333333333333333333333

4444444444444444444444444444444444444444

5555555555555555555555555555555555555555

6666666666666666666666666666666666666666

7777777777777777777777777777777777777777

8888888888888888888888888888888888888888

9999999999999999999999999999999999999999

Che ne dici di una soluzione programmatica?

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" maiuscola è convenzionalmente la più ampia.

Credo che la lettera Wsia la più ampia.

A seconda della tua piattaforma, potrebbe esserci un modo per "getWidth" da una stringa o una funzione DrawText () in qualche modo con una proprietà width.

Vorrei fare un semplice algortime che utilizzava il carattere necessario e poi correva attraverso l'alfabet e lo memorizzava in una piccola configurazione o lo calcolava all'inizializzazione come un ciclo dalla A alla Z non è poi così difficile.

Dipende anche dal carattere. L'ho fatto 1 o 2 anni fa con Processing ed Helvetica ed è ILJTYFVCPAXUZKHSEDORGNBQMW in ordine crescente di pixel. L'idea è di disegnare il testo su una tela con il carattere che stai guardando, contare i pixel, quindi ordinare con un HashMap o un Dizionario.

Naturalmente, questo potrebbe non essere direttamente pertinente al tuo utilizzo in quanto calcola l'area dei pixel piuttosto che solo la larghezza. Potrebbe anche essere un po 'eccessivo.

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 - V vince .

Una soluzione per calcolare la larghezza dei caratteri un po 'come la soluzione pubblicata da xxx è stata pubblicata da Alex Michael sul suo blog (che stranamente mi ha collegato qui).

Sommario:

• Per Helvetica, le prime tre lettere sono: M (2493 pixel), W (2414) e B (1909).
• Per una serie di caratteri forniti con il suo Mac, i risultati sono più o meno gli stessi: M (2217,51 ± 945,19), W (2139,06 ± 945,29) e B (1841,38 ± 685,26).

Post originale: http://alexmic.net/letter-pixel-count/

Codice:

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

Dipenderà dal carattere. Vorrei creare un piccolo programma in un linguaggio di programmazione con cui ti trovi più a tuo agio, in cui disegni ogni lettera dell'alfabeto in una bitmap di dimensioni m volte. Inizializza ogni pixel con il bianco. Quindi conta il numero di pixel bianchi dopo aver disegnato ogni lettera e salva quel numero. Il numero più alto che trovi è quello che stai cercando.

EDIT: Se in realtà sei solo interessato a quale occupa il rettangolo più grande (ma sembra che tu sia davvero dopo quello, non i pixel), puoi usare varie chiamate API per trovare le dimensioni, ma dipende da il tuo linguaggio di programmazione. In Java, ad esempio, useresti la classe FontMetrics.

So che la risposta accettata qui è W, W è per WIN.

Tuttavia, in questo caso, W è anche per Larghezza. Il case study utilizzato utilizzava un semplice test di larghezza per esaminare i pixel, ma era solo la larghezza, non il conteggio totale dei pixel. Come semplice esempio di contatore, la risposta accettata presuppone che O e Q occupino la stessa quantità di pixel, ma occupano solo la stessa quantità di spazio.

Pertanto, W occupa più spazio . Ma sono tutti i pixel che sono craccati?

Prendiamo alcuni dati empirici. Ho creato immagini imgur dalle seguenti B, M e W. Ho quindi analizzato il loro numero di pixel (vedi sotto), ecco i risultati:

B: 114 pixel

M: 150 pixel

L: 157 pixel

Ecco come li ho inseriti nella tela e analizzato i dati dei pixel grezzi dalle immagini.

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>

Vuoi conoscere il vero glifo più lungo, non solo indovinare?
E non sto solo parlando di lettere, cifre e simboli comuni (!, @ E così via). Intendo il glifo più lungo in tutti i 32.834 caratteri di UTF-16.
Quindi ho iniziato con la risposta di @NK che aveva una soluzione programmatica e vi ho apportato alcune lievi modifiche:

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

Dopo aver eseguito questo e in attesa (e in attesa), dà l'output ௌ won.
E il gioco è fatto, il personaggio più lungo in UTF-32! Si noti che su alcuni caratteri il glifo più lungo è ﷽, ma gli altri caratteri (specialmente quelli monospaziali) si sovrappongono ai caratteri, come con il carattere che il programma considera l'account del programma.

Dipende dal carattere. Lo zero incrociato, ad esempio, occupa molto più di uno normale.

Ma se uno potesse fare un'ipotesi, andrei con X o B.