Contest di funzioni garble
https://stackoverflow.com/questions/4964687
-
12-11-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianDomanda
Ricorda quel messaggio in trasferta su AIM che diceva come:
Aocccdrnig to a rschearch a cmabrigde uinervtisy, non è stato in grado di non essere in waht oredr i ltteers in un wrod, l'olny ipmoetnt tihng è il frist e lsat ltteer be the rghit pclae. La RSET può essere un mses toatl e puoi sedersi per ravvedarlo wouthit porbelm. Tihs è bcuseae the huamn mnid deos non raed ervey lteter di iStlef, ma il wrod come un wlohe.
Comunque sto cercando di fare una funzione che lo farebbe a un'intera pagina. Ci sono alcune regole per questa funzione.
- Meno di 4 caratteri lasciano soli.
- I personaggi non alfanumerici non contano come parte della parola.
- Le parole sillanate sono davvero due parole
- Le parole devono essere confuse se lunghezza> = 4 (non può essere come l'originale)
- Il primo e l'ultimo carattere rimangono lo stesso e solo i caratteri di mezzo si fanno confusione (grazie Hersheezy)
- Il testo dovrebbe essere sempre casuale e produrre un solo Giobbrontura su ogni corsa
- Puro javascript e iterate su tutti i nodi di testo
- Vince il codice più dolce più dolce.
Comunque sembra abbastanza semplice da implementare, come si tratta di iniziare un concorso per vedere chi potrebbe rendere il codice più chiaro per svolgere questo compito. Sentiti libero di prendere in prestito senza riconoscere dal mio codice (ho def)
Se mi sono perso qualcosa aggiungilo nei commenti. Comunque ci ho lavorato in modo molto hackish e ecco che mostra il mio lavoro meno che pari
var i, j, words, textNodes, punct = /[^a-zA-Z0-9]/;
Array.prototype.shuffle = function() {
for (var i = 0; i < this.length; i++) {
var j = i;
while (j == i) {
j = Math.floor(Math.random() * this.length);
}
var tmp = this[i];
this[i] = this[j];
this[j] = tmp;
}
return this;
};
String.prototype.shuffle = function() {
return this.split('').shuffle().join('');
};
function transverse(element, array) {
if (!array) array = [];
if (element.nodeType === 3) {
array.push(element);
} else {
for (var i = 0; i < element.childNodes.length; i++) {
transverse(element.childNodes[i], array);
}
}
return array;
}
function garble(str) {
if (!str) return '';
str = str.trim();
if (/-/.test(str)) {
str = str.split('-');
for (var i = 0; i < str.length; i++) {
str[i] = garble(str[i]);
}
return str.join('-')
}
if (punct.test(str.charAt(0))) {
return str.charAt(0) + garble(str.slice(1));
}
if (punct.test(str.charAt(str.length - 1))) {
return garble(str.slice(0, -1)) + str.charAt(str.length - 1);
}
if (str.length < 4) return str;
if (str.length === 4) return str.charAt(0) + str.charAt(2) + str.charAt(1) + str.charAt(3)
return str.charAt(0) + str.substr(1, str.length - 2).shuffle() +
str.charAt(str.length - 1);
}
window.onload = function() {
textNodes = transverse(document.documentElement);
for (i = 0; i < textNodes.length; i++) {
words = textNodes[i].data.split(' ');
for (j = 0; j < words.length; j++) {
words[j] = garble(words[j]);
}
textNodes[i].data = words.join(' ');
}
};
Soluzione
Aggiornamento (ultimo): Non pensare che possa diventare più piccolo .. Demo
Ultimo compresso (332):
var e=document.body.getElementsByTagName('*'),j,i,l,x,t,b;for(i=0;e[i];i++)for(j=0;b=e[i].childNodes[j];j++)if(b.nodeType==3)b.data=b.data.replace(/\w{4,}/g,function(w){if(/(^.)(\1)+$/.test(x=w.substring(1,l=w.length-1)))return w;t=w;while(t==w)t=w[0]+x.split('').sort(function(){return 0.5-Math.random()}).join('')+w[l];return t});
codice:
var e = document.body.getElementsByTagName('*'),
j, i, l, x, t, b;
for (i = 0; e[i]; i++)
for (j = 0; b = e[i].childNodes[j]; j++)
if (b.nodeType == 3) b.data = b.data.replace(/\w{4,}/g, function(w) {
if (/(^.)(\1)+$/.test(x = w.substring(1, l = w.length - 1))) return w;
t = w;
while (t == w)
t = w[0] + x.split('').sort(function() {
return 0.5 - Math.random();
}).join('') + w[l];
return t;
});
AGGIORNARE anche .. più piccolo ..
Versione anche più piccola
Non so il minificatore che stai usando, ma questo deve essere almeno (MODIFICARE 108) byte più piccoli.
Versione compressa (365 byte):
var e=document.body.getElementsByTagName('*'),a=[],c,j,i,l,x,t,b;for(i=0;c=e[i];i++)for(j=0;b=c.childNodes[j];j++)if(b.nodeType==3){b.data=b.data.replace(/\b[a-z0-9]{4,}\b/gi,function(w){if(/(^.)(\1)+$/.test(x=w.substring(1,l=w.length-1)))return w;t=w;while(t==w)t=w[0]+x.split('').sort(function(){return Math.floor(Math.random()*2)?1:-1}).join('')+w[l];return t})}
Codice:
var e = document.body.getElementsByTagName('*'),
a = [],
c, j, i, l, x, t, b;
for (i = 0; c = e[i]; i++)
for (j = 0; b = c.childNodes[j]; j++)
if (b.nodeType == 3) {
b.data = b.data.replace(/\b[a-z0-9]{4,}\b/gi, function(w) {
if (/(^.)(\1)+$/.test(x = w.substring(1, l = w.length - 1))) return w;
t = w;
while (t == w)
t = w[0] + x.split('').sort(function() {
return Math.floor(Math.random() * 2) ? 1 : -1;
}).join('') + w[l];
return t;
});
}
MODIFICARE
DEMO NUOVE REGOLE
CODICE:
var fn = function(e) {
var ret = [],c;
for (var i = 0; i < e.length; i++) {
c = e[i].childNodes;
for (var j = 0; j < c.length; j++)
if (c[j].nodeType === 3) ret.push(c[j]);
}
return ret;
};
var es = fn(document.body.getElementsByTagName('*'));
for (var i = 0; i < es.length; i++) {
var e = es[i],len,x;
e.data = e.data.replace(/\b[a-z0-9]{4,}\b/gi, function(w) {
if (/(^.)(\1)+$/.test(x = w.substring(1, len = w.length - 1))) return w;
var tmp = w;
while (tmp === w) {
tmp = w[0] + x.split('').sort(function() {
return Math.floor(Math.random() * 2) ? 1 : -1;
}).join('') + w[len];
}
return tmp;
});
}
Ciò dovrebbe rispettare tutte le regole e mantenere il formato e la punteggiatura. Demo
//select all nodes in document and perform map on it to filter out
//non text node types, then each one of those elements is processed.
$('*').contents().map(function(i, elem) {
if (elem.nodeType !== 3) return null;
else return elem;
}).each(function(i, elem) {
//call strip funciton defined down to get an object, with a word array, and
//charecters which was stripped along with there index in the orginal string
var str1 = '',
tmp = strip(elem.data),
words = tmp.words,
sentence;
// shuffle all words
words = $.map(words, function(x, i) {
return shuffle(x);
});
//construct raw sentence (non alphanumeric charecters)
sentence = words.join('');
//reinsert spaces and punctiouation
$.each(tmp.chars, function(i, elem) {
sentence = sentence.substring(0, elem.index) + elem.char + sentence.substring(elem.index - 1 + elem.char.length);
});
//set the element text
elem.data = sentence;
});
//shuffle funciton takes a word and shuffle the charecters between the last and the firt
function shuffle(txt) {
//if the word is smaller than 4 charecters or it has repeated charecters in
//its middle (i.e. loop, 'oo' cannot be shuffled!) then return it;
if (txt.length < 4 || /(^.)(\1)+$/.test(txt.substring(1, txt.length - 1)))
return txt;
var str = txt.split(''),
ret = [],
rand, x = 0,
tmp = txt;
//while the txt hasn't changed in the first randomization cycle then repeated
while (txt === tmp) {
ret = [];
$.each(str, function(i, c) {
if (i === str.length - 1 || i === 0) {
ret[i] = c;
return;
}
while (true) {
rand = Math.floor(Math.random() * (str.length - 2) + 1);
if (!ret[rand]) {
ret[rand] = c;
break;
}
}
});
tmp = ret.join('');
}
return ret.join('');
}
function strip(txt) {
var punc = /[^A-Za-z0-9]/g,
res, nonAlphaNum = [],
arr;
//punc regex is all non-alphanumeric charecters which will act on the string
//to point out unwanted charecters and store them in an array along with
//their index
while ((res = punc.exec(txt)) != null) {
nonAlphaNum.push({
index: res.index,
char: res[0]
});
}
//split into words
arr = txt.split(/\s/);
//remove punctiuation and other unwanted chars
arr = $.map(arr, function(x, i) {
return x.replace(punc, '');
});
return {
words: arr, //words array
chars: nonAlphaNum //array of stripped charecter objects (chars, index in orginal)
};
}
BTW Bella scelta dell'articolo, WWIWIEKIKB !!
Altri suggerimenti
Aggiornato
Quindi non ho potuto fare a meno di giocare un po 'con questa cosa e vedere quali altri modi potrei manipolare il documento con il minor codice possibile. Basti dire che può essere abbreviato per funzionare in uno/o scenario, ma mi piace fare cose con le opzioni con cui l'utente può giocare.
Detto questo, ecco alcune variazioni su quanto sopra e benefici/delusioni:
Presentazione ufficiale (473 BYTES)
Minimizzato (473 bytes) 1
function t(e){var r=[],w;for(w=0;w<e.length;w++){if(e[w].nodeType===3)r.push(e[w]);else if(e[w].childNodes)r=r.concat(t(e[w].childNodes));}return r;}var e,x=t(document.body.childNodes),y,z;for(y=0;y<x.length;y++){x[y].data=x[y].data.replace(/\b[a-z]{4,}\b/ig,function(w){if(w.length==4&&(/^.([a-z])\1./i).test(w))return w;e=w;while(e==w){z=w.split('');e=z[0]+(z.slice(1,z.length-1).sort(function(a,b){return(Math.random()*2)>1?1:-1;}).join(''))+z[z.length-1];}return e;});}
Versione non minimizzata: (479bytes) 1
function t(e){
var r=[],w;
for(w=0;w<e.length;w++){
if(e[w].nodeType===3)r.push(e[w]);
else if(e[w].childNodes)r=r.concat(t(e[w].childNodes));
}
return r;
}
var x=t(document.body.childNodes);
for(var y=0;y<x.length;y++){
x[y].data=x[y].data.replace(/\b[a-z]{4,}\b/ig,function(w){
if(w.length==4&&(/^.([a-z])\1./i).test(w))
return w;
var e=w;
while (e==w){
var x=w.split('');
e=x[0]+(x.slice(1,x.length-1).sort(function(a,b){
return(Math.random()*2)>1?1:-1;
}).join(''))+x[x.length-1];
}
return e;
});
}
- Nessun uso di jQuery ("puro javascript")
- Aggiungere
<script src="garble.js"></script>appena sopra</body>o avvolgere il codice in un evento Onload.
1 Re-Placement delle dichiarazioni var lo rende più breve, vedi 479 bytes vs 473 BYES)
Versioni aggiuntive
Di base (Demo)
// jQuery Garble
// "Basic" version
//
// Requirements:
// 1. Find all words 4+ letters long (exclude hyphens, punctuation or numbers from
// the classification)
// 2. The words being garbled must follow:
// a. They can not remain the same as the previous state
// b. The first and last character must remain in-tact
// 3. The garbling must be random and produce a new result each iteration.
//
// Usage:
// $(selector).garble(options);
//
(function($){
$.fn.extend({
garble: function(options){
// basic options
var o = $.extend({
flagChanges: false,
changeClass: 'modified'
},options);
// iterate over elements
return this.each(function(i,e){
var txt = $(e).text();
// locate words with 4+ letters
$(e).html(txt.replace(/\b[a-z]{4,}\b/ig,function(w){
var e = w;
// make sure we get an altered word back
while (e==w){
var x = w.split('');
e = x[0]+(x.slice(1,x.length-1).sort(function(y,z){
return (Math.random()*2)>1?1:-1; // randomize
}).join(''))+x[x.length-1];
}
return (o.flagChanges?'<span class="'+o.changeClass+'">'+e+'</span>':e);
}));
});
}
});
})(jQuery);
Professionisti
- Molto magro e rifinito
- Le opzioni che consentono di modificare la parola modificata (avvolge ogni modifica in un arco di intervallo con la classe "modificata" predefinita o una classe di scelta).
Contro
- Non funzionerà con elementi nidificati (questo significa che devi selezionare l'elemento più basso possibile nell'albero DOM. Quindi, se stai solo facendo paragrafi senza collegamenti ipertestuali o campate all'interno, questo è il tuo vincitore)
- Se gli elementi che hanno figli vengono utilizzati nel selettore, la loro formattazione HTML (come un collegamento a un paragrafo) verrà spogliata.
Sottile e rifinito (Demo)
$(function(){ // on load
$('*','body').contents().map(function(i,e){ // grab all elements,
return e.nodeType !== 3 ? null : e; // then filter by textual elements
}).each(function(i,e){ // amd iterate through them.
e.data = e.data.replace(/\b[a-z]{4,}\b/ig, function(w) { // go through and find 4+ letters words
if (w.length==4&&w.substring(1,2)==w.substring(2,3)) // (avoid infinite loops on words that
return w; // can't be changed [e.g. look])
var e = w; // Store the original word for comparison, but
while (e==w){ // keep scrambling until we have a new word.
var x = w.split(''); // (do so by breaking out middle letters in to array,
e = x[0] + (x.slice(1, x.length - 1).sort(function(a,b){ // then sort those middle letters
return (Math.random() * 2) > 1 ? 1 : -1; // based on a random number)
}).join('')) + x[x.length - 1]; // Now, rejoin it all back together
}
return e; // and finally return the modified result.
});
});
});
Completamente presente (Demo)
// jQuery Garble
// "Feature Rich" version
//
// Requirements:
// 1. Find all words 4+ letters long (exclude hyphens, punctuation or numbers from
// the classification)
// 2. The words being garbled must follow:
// a. They can not remain the same as the previous state
// b. The first and last character must remain in-tact
// 3. The garbling must be random and produce a new result each iteration.
//
// Usage:
// $(selector).garble(options);
//
(function($) {
$.fn.extend({
garble: function(options) {
var o = $.extend({}, $.fn.garble.defaults, options);
// takes in a string and performs the necessary manipulation(s) on it. Use regex
// to only collect words greater than or equal to 4 characters long, and consider
// punctuation not part of the word.
var garbleStr = function(s,t){
return s.replace(/\b[a-z]{4,}\b/ig, function(w) {
var e = o.algorithm(w);
// if we're not performing a low-level parse and they want the changes styled,
// return a span with either the detault class or their custom class
if (t && !o.lowLevel && o.highLevel.flagChanges)
return '<span class="'+o.highLevel.changeClass+'">'+e+'</span>';
// just return the new word
return e;
});
};
// Very high-level process.
// Will only change the lowest node's text (so a paragraph
// with links, only the links will be altered)
var highLevel = function(i, e) {
// we're not at the bottom element, keep going
if ($(e).children().length>0){
return $(e).children().each(highLevel);
}
var t = $(e).text();
$(e).html(garbleStr(t,e.tagName!=='TEXTAREA'));
};
// Low level process
// Goes down to each individual element and changes it
var lowLevel = function(i, e) {
var d = e.data;
e.data = garbleStr(d);
};
// depending their selection, execute either or
if (o.lowLevel){
return this.find('*').contents().map(function(i, e) {
return (e.nodeType !== 3 ? null : e);
}).each(lowLevel);
}else{
return this.contents().each(highLevel);
}
},
});
// Defaults
$.fn.garble.defaults = {
// Perform low-level modification? (Modifies all words it finds,
// not just the one farthests down the tree)
lowLevel: false,
// when lowLevel is set to false, these options are available:
highLevel: {
// wrap changes in a <span>
flagChanges: false,
// the class being applied to the above <span>
changeClass: 'modified'
},
// function used to garble the text. This will be passed each word
// individually and should return the new word's value.
algorithm: function(w) {
// if w = "hello":
// 1. Make an array out of the letters.
// 2. keep the first and last in-tact, but use .slice() to extract the middle
// 3. Perform the specified algorithm on the middle characters
// 4. return result
var e = w;
while (e==w){ // secure it gets changed
var x = w.split('');
e = x[0] + (x.slice(1, x.length - 1).sort(function(a,b){
return (Math.random() * 2) > 1 ? 1 : -1;
}).join('')) + x[x.length - 1];
}
return e;
}
};
})(jQuery);
Professionisti
- Flessibile. Funzionerà in quasi tutti gli scenari, sebbene un elemento a catena dal fondo del cibo rapido a procedere o chiamandolo sull'intero
<body>-Questo può gestirlo. - Molto personalizzabile:
- Può specificare per eseguire modifiche a basso livello (ogni elemento) o di alto livello (solo elementi senza figli)
- Può specificare se si desidera mostrare le modifiche e quale classe applicare (le modifiche sono avvolte in un arco con il nome della classe specificato)
- Può specificare una funzione da utilizzare per lo scrambling (forse vuoi semplicemente invertire le parole o utilizzare un metodo migliore)
Contro
- Poco più sopra la testa, anche se è ancora veloce.
- Forse troppe opzioni o semplicemente troppo gonfie.
- Sono sicuro che qualcuno troverà altri contro
Ecco la mia opinione sulla funzione. Vedere la demo qui.
- Usa l'eccellente jQuery.ba-replaceText Plug -in per gestire la ricerca di solo nodi di testo
- Gestisce le parole di lunghezza arbitraria in cui tutti i personaggi interni sono uguali
- Facile da capire con nomi descrittivi
Versione completa (1187 byte):
/* Called on document.ready */
$(function () {
$("body *").replaceText(/\b([A-z]{4,})\b/g, scramble_inner );
});
/* Scramble the inner characters of a word */
function scramble_inner(word) {
return word[0]
+ force_shuffle(word.slice(1, word.length - 1))
+ word[word.length - 1];
}
/* Randomize characters in the string, but check to make sure
* they're different from the original. Handle's the special
* case where all inner characters are equal, for instance "moooo".
*/
function force_shuffle(str) {
if (all_chars_same(str)) return str;
var result = str;
while (str === result) {
result = str.split('').sort(function() {
return Math.floor(Math.random() * 2) ? 1 : -1;
}).join('');
}
return result;
}
/* Check whether all characters in the string are equal, eg "ooo" */
function all_chars_same(str) {
for (i = 0; i < str.length; i++) {
if (str[i] !== str[0]) {
return false;
}
}
return true;
}
Versione minificata (348 byte):
$(function(){$("body *").replaceText(/\b([A-z]{4,})\b/g,a)});function a(w){return w[0]+b(w.slice(1,w.length-1))+w[w.length-1]}function b(s){if(c(s))return s;var r=s;while(s===r){r=s.split('').sort(function(){return Math.floor(Math.random()*2)?1:-1}).join('')}return r}function c(s){for(i=0;i<s.length;i++){if(s[i]!==s[0]){return false}}return true}
Nota: ho eseguito questo tramite JSLINT, che potrebbe essere stata una cattiva idea. Comunque, la demo è qui.
function shuffle(letters) {
var i = letters.length - 2;
while (i > 1) {
var pos = Math.floor(Math.random() * i) + 1;
var tmp = letters[i];
letters[i] = letters[pos];
letters[pos] = tmp;
i--;
}
}
function scramble(word) {
if (word.slice(1, -2) == word.slice(2, -1)) {
return word;
}
var letters = word.split('');
var result = word;
while (result == word) {
shuffle(letters);
result = letters.join('');
}
return result;
}
function process(node) {
var data = node.data;
if (/[a-z]{4}/i.test(data)) {
node.data = data.replace(/[a-z]{4,}/gi, scramble);
}
}
function traverse(element) {
var node = element.firstChild;
while (node) {
if (node.nodeType == Node.ELEMENT_NODE) {
traverse(node);
} else if (node.nodeType == Node.TEXT_NODE) {
process(node);
}
node = node.nextSibling;
}
}
function garble() {
traverse(document.body);
}
window.onload = garble;
Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
