Tâche

Votre tâche consiste à produire une chaîne contenant des caractères moyens de chaîne. Le premier caractère du résultat serait le caractère moyen du premier caractère (qui est le premier caractère) et la moyenne du deuxième caractère de deux premiers caractères et ainsi de suite.

Quel est le caractère moyen?

Les chaînes sont des tableaux d'octets. Le caractère moyen de la chaîne peut être trouvé en calculant la moyenne des valeurs ASCII des caractères de la chaîne et en prenant le caractère ASCII correspondant.

Par exemple, une chaîne "Hello!"peut être écrite sous forme de séquence d'octets 72 101 108 108 111 33. La moyenne des valeurs ascii est 533/6 = 88.833 ... et quand elle est arrondie à l'entier le plus proche, nous obtenons 89 qui est le code ascii pour la lettre captive Y.

Règles

• Vous pouvez supposer que l'entrée ne contient que des caractères ASCII imprimables
• L'entrée peut être lue depuis stdin ou comme arguments de ligne de commande ou comme arguments de fonction
• La sortie doit être standard. Si votre programme est fonctionnel, vous pouvez également renvoyer la chaîne que vous auriez sinon imprimée.
• Il doit s'agir d'un programme ou d'une fonction dans son intégralité, et non d'un extrait
• Des échappatoires standard s'appliquent
• Les entiers sont arrondis par fonction floor(x+0.5)ou fonction similaire.

Comment gagner?

C'est le code-golf , donc la réponse la plus courte (en octets) en victoires.

Exemples

• Hello! → HW^adY
• test → tmop
• 42 → 43
• StackExchange → Sdccd_ccccddd

Brainfuck 106 octets

,[>,<.[->+<]>>++<[>[->+>+<<]>[-<<-[>]>>>[<[>>>-<<<[-]]>>]<<]>>>+<<[-<<+>>]<<<]>[-]>>>>[-<<<<<+>>>>>]<<<<<]

C'est ma première participation à un code-golf, soyez gentil! Cela fonctionne, mais brainfuck ne peut pas gérer les flottants (pas que je sache), donc la valeur arrondie est toujours la plus basse (pourrait corriger mon algorithme plus tard).

De plus, l'algorithme fait la moyenne des valeurs 2 par 2, ce qui signifie qu'il pourrait être inexact à certains endroits. Et je dois aussi corriger un bug qui imprime un nombre à la fin de la sortie.

Pyth, 16 octets

smCs+.5csaYCdlYz

Assez simple. Utiliser s+.5au lieu d'arrondir, car pour une raison quelconque, round(0.5, 0)c'est 0 en Python.

Q, 15 12 octets

12 octets comme expression

"c"$avgs"i"$

q)"c"$avgs"i"$"Hello!"
"HW^adY"
q)"c"$avgs"i"$"test"
"tmop"
q)"c"$avgs"i"$"42"
"43"
q)"c"$avgs"i"$"StackExchange"
"Sdccd_ccccddd"

ou 15 octets en fonction

{"c"$avgs"i"$x}

q){"c"$avgs"i"$x} "Hello!"
"HW^adY"
q){"c"$avgs"i"$x} "test"
"tmop"
q){"c"$avgs"i"$x} "42"
"43"
q){"c"$avgs"i"$x} "StackExchange"
"Sdccd_ccccddd"

profite de

1. le "i" $ cast pour convertir une chaîne (liste de caractères) en une liste d'entiers
2. la fonction avgs, qui calcule la moyenne courante d'une liste comme une liste de flottants
3. le "c" $ cast pour convertir une liste de flottants en une liste de caractères, et qui arrondit automatiquement chaque flottant à l'entier le plus proche avant de le faire [ie ("c" $ 99,5) = ("c" $ 100) et ("c "99,4 $) = (" c "99 $)]

CJam, 19 octets

Uq{i+_U):Ud/moco}/;

Essayez-le en ligne dans l' interpréteur CJam .

Perl: 31 30 caractères

(Code de 29 caractères + option de ligne de commande de 1 caractère.)

s!.!chr.5+($s+=ord$&)/++$c!ge

Exemple d'exécution:

bash-4.3$ perl -pe 's!.!chr.5+($s+=ord$&)/++$c!ge' <<< 'StackExchange'
Sdccd_ccccddd

C # 189135134106 octets

var x=s.Select((t,i)=>Math.Round(s.Select(a=>(int)a).Take(i+1).Average())).Aggregate("",(m,c)=>m+(char)c);

Peut être vu ici

Golfeur pour la première fois

K, 36 octets

`0:_ci_.5+{(+/x)%#x}'.0+1_|(-1_)\_ic

Usage:

  `0:_ci_.5+{(+/x)%#x}'.0+1_|(-1_)\_ic"Hello!"
HW^adY
  `0:_ci_.5+{(+/x)%#x}'.0+1_|(-1_)\_ic"test"
tmop
  `0:_ci_.5+{(+/x)%#x}'.0+1_|(-1_)\_ic"42"
43
  `0:_ci_.5+{(+/x)%#x}'.0+1_|(-1_)\_ic"StackExchange"
Sdccd_ccccddd

_ciet _icconvertir ascii en caractères et vice versa, respectivement. {(+/x)%#x}est un idiome K classique pour calculer une moyenne. Assez simple dans l'ensemble.

Edit: oh, mal lu la spécification. `0: est nécessaire pour imprimer le résultat sur stdout. En attente de clarification sur l'entrée re. Question de Dennis.

Mathematica, 75 octets

FromCharacterCode@Floor[.5+Accumulate@#/Range@Length@#]&@ToCharacterCode@#&

Julia, 85 81 octets

s->(i=[int(c)for c=s];print(join([char(iround(mean(i[1:j])))for j=1:length(i)])))

Cela crée une fonction sans nom qui accepte une chaîne et crée un vecteur de ses points de code ASCII. Des moyennes sont prises pour chaque groupe séquentiel, arrondies à des entiers, converties en caractères, jointes en une chaîne et imprimées dans STDOUT.

Rubis, 46

s=0.0
$<.bytes{|b|s+=b;$><<'%c'%(0.5+s/$.+=1)}

ideone .

Je m'excuse auprès de w0lf, ma réponse s'est avérée suffisamment différente pour que cela semble valoir la peine d'être publié.

$<.bytesitère sur chaque octet dans stdin, nous imprimons donc la moyenne mobile dans chaque boucle. '% c' convertit un flottant en caractère en arrondissant et en prenant l'ASCII, donc tout ce que nous avons à faire est d'ajouter 0,5 pour le faire arrondir correctement. $.est une variable magique qui commence initialisée à 0 - elle est censée stocker le nombre de lignes, mais comme nous voulons ici le nombre d'octets, nous l'incrémentons manuellement.

Mathcad, 60 "octets"

Mathcad est une application mathématique basée sur des feuilles de calcul 2D composées de "régions" dont chacune peut être du texte, une expression mathématique, un programme, un tracé ou un composant scripté.

Une instruction mathématique ou de programmation est sélectionnée dans une barre d'outils de palette ou saisie à l'aide d'un raccourci clavier. À des fins de golf, une opération ("octet") est considérée comme le nombre d'opérations au clavier nécessaires pour créer un nom ou une expression (par exemple, pour définir la variable a sur 3, nous écririons a: = 3. L'opérateur de définition : = est une simple pression sur la touche ":", de même que a et 3 donnant un total de 3 "octets". La programmation pour l' opérateur nécessite de taper ctl-shft- # (ou un simple clic sur la barre d'outils de programmation) donc à nouveau est équivalent à 1 octet.

Dans Mathcad, l'utilisateur entre des commandes de langage de programmation à l'aide de raccourcis clavier (ou en les sélectionnant dans la barre d'outils de programmation) plutôt que de les écrire dans du texte. Par exemple, taper ctl-] crée un opérateur de boucle while qui a deux "espaces réservés" pour entrer la condition et une seule ligne du corps, respectivement. En tapant = à la fin d'une expression Mathcad, Mathcad évalue l'expression.

(Nombre d'octets) En le regardant du point de vue de l'utilisateur et en assimilant une opération d'entrée Mathcad (clavier généralement, clic de souris sur la barre d'outils si aucun raccourci kbd) à un caractère et en l'interprétant comme un octet. csort = 5 octets car il est tapé char-by-char comme le sont les autres noms de variable / fonction. L'opérateur for est une construction spéciale qui occupe 11 caractères (dont 3 "espaces réservés" vides et 3 espaces) mais est entrée par ctl-shft- #, donc = 1 octet (similaire aux jetons dans certaines langues). Taper '(citation) crée des parenthèses équilibrées (généralement) et compte donc pour 1 octet. Indexation v = 3 octets (type v [k).

Python 3, 66 octets

Si j'utilise à la round()place de int(.5+etc., il enregistre un caractère, mais n'est techniquement pas conforme au défi: les arrondis de Python se round()divisent en deux à l'entier pair le plus proche, pas vers le haut. Cependant, il fonctionne correctement sur toutes les entrées d'échantillon.

Je me sens également un peu sale pour ne pas terminer la sortie avec une nouvelle ligne, mais le défi ne nécessite pas que ...

n=t=0
for c in input():n+=1;t+=ord(c);print(end=chr(int(.5+t/n)))

JavaScript (ES6), 75 octets

let f =
s=>s.replace(/./g,x=>String.fromCharCode((t+=x.charCodeAt())/++i+.5),i=t=0)

<input oninput="O.value=f(this.value)" value="Hello!"><br>
<input id=O value="HW^adY" disabled>

Je ne peux pas croire qu'il n'y ait pas encore de réponse JS avec cette technique ...

Python 2, 71

i=s=0
r=''
for c in input():s+=ord(c);i+=1.;r+=chr(int(s/i+.5))
print r

Avec chaque nouveau caractère, met à jour la somme des caractères set le nombre de caractères ipour calculer et ajouter le caractère moyen.

Rubis 59 61

->w{s=c=0.0;w.chars.map{|l|s+=l.ord;(s/c+=1).round.chr}*''}

Test: http://ideone.com/dT7orT

Java, 100

Tout comme beaucoup d'autres réponses ici, je fais la somme et la moyenne en boucle. Juste ici pour représenter Java :)

void f(char[]z){float s=0;for(int i=0;i<z.length;System.out.print((char)Math.round(s/++i)))s+=z[i];}

Mon code d'origine est un 97, mais il ne renvoie que le modifié char[]plutôt que de l'imprimer:

char[]g(char[]z){float s=0;for(int i=0;i<z.length;z[i]=(char)Math.round(s/++i))s+=z[i];return z;}

Maintenant, c'est juste assez long pour que les barres de défilement apparaissent pour moi, alors voici une version avec quelques sauts de ligne, juste parce que:

void f(char[]z){
    float s=0;
    for(int i=0;
            i<z.length;
            System.out.print((char)Math.round(s/++i)))
        s+=z[i];
}

C, 62 octets

c;t;main(n){for(;(c=getchar())>0;n++)putchar(((t+=c)+n/2)/n);}

(lien idéone)

Les résultats sont légèrement différents des exemples de l'OP, mais uniquement parce que ce code arrondit 0,5 vers le bas au lieu de monter. Plus maintenant!

R, 135 127 Octets

Cela est devenu très rapide et je me suis vraiment trompé la première fois :) Besoin de lire correctement les questions.

cat(sapply(substring(a<-scan(,''),1,1:nchar(a)),function(x)rawToChar(as.raw(round(mean(as.integer(charToRaw(x)))+.5)))),sep='')

Essai

cat(sapply(substring(a<-scan(,''),1,1:nchar(a)),function(x)rawToChar(as.raw(round(mean(as.integer(charToRaw(x)))+.5)))),sep='')
1: Hello!
2: 
Read 1 item
HW^adY

Perl 5, 41 octets

say map{$s+=ord;chr($s/++$c+.5)}pop=~/./g

courir comme

$ perl -E 'say map{$s+=ord;chr($s/++$c+.5)}pop=~/./g' StackExchange
Sdccd_ccccddd

TSQL, 118 octets

DECLARE @ varchar(400) = 'StackExchange'

SELECT
top(len(@))char(avg(ascii(stuff(@,1,number,''))+.5)over(order by number))FROM
master..spt_values
WHERE'P'=type

Retour des caractères à la verticale

S
d
c
c
d
_
c
c
c
c
d
d
d

> <> , 30 octets

i:0(?v
v &l~<
\+l2(?
\&,12,+o;

• La première ligne lit depuis stdin et place les caractères sur la pile
• Le second supprimera le caractère EOL, prendra la taille de la pile et le mettra dans le & registre
• La troisième ligne ajoutera des numéros sur la pile alors qu'il y en a deux ou plus
• La quatrième ligne divisera le nombre résultant par la valeur du registre, puis ajoutera 1/2, affichera la valeur sous forme de caractère et s'arrêtera. Face à une valeur flottante lors de l'affichage d'un caractère,> <> le plancher, c'est pourquoi nous avons ajouté 1/2

Vous pouvez l'essayer sur l' interpréteur en ligne, mais vous devez ensuite utiliser la version suivante, car l'interpréteur en ligne remplit la zone de code dans un rectangle et s'applique ?aux espaces.

i:0(?v
v &l~<
\+l2(   ?
\&,12,+o;

05AB1E , 15 octets [non concurrentiel?]

.pvyDSÇOsg/îç}J

Essayez-le en ligne!

Japt , 13 octets (non concurrent)

£T±Xc)/°Y r d

Testez-le en ligne!

Comment ça marche

£   T± Xc)/° Y r d
mXY{T+=Xc)/++Y r d}
                     // Implicit: U = input string, T = 0
mXY{              }  // Replace each char X and index Y in the string by this function:
    T+=Xc            //   Add X.charCodeAt() to T.
         )/++Y       //   Take T / (Y + 1).
               r d   //   Round, and convert to a character.
                     // Implicit: output result of last expression

Japt , 11 octets

c@V±X /°T r

Essayez-le

PHP , 176 octets

<?=(implode('',array_reduce(str_split($argv[1]),function($c,$k){array_push($c[1],chr(floor(((ord($k)+$c[0])/(count($c[1])+1))+0.5)));return[ord($k)+$c[0],$c[1]];},[0,[]])[1]));

Exemple:

>php cg.php Hello!
HW^adY
>php cg.php test  
tmop
>php cg.php 42
43

La plus grande solution jusqu'à présent, mais basée sur php, elle ne peut pas être beaucoup plus courte je pense. 2 octets pourraient être enregistrés en supprimant les sauts de ligne.

JavaScript ES7, 122 octets

s=>String.fromCharCode(...[for(i of s)i.charCodeAt()].map((l,i,a)=>Math.round(eval((t=a.slice(0,++i)).join`+`)/t.length)))

Surtout tout se passe dans ce morceau

eval((t=a.slice(0,++i)).join`+`)/t.length)

Le reste est en boucle / conversion de code de caractère

Séparer:

s=> 
 String.fromCharCode(...                        ) // Converts average character code array to string, ... allows it to take an array
   [for(i of s)i.charCodeAt()]                    // Converts string to char code array
   .map((l,i,a)=>                             )   // Loops through each character
     Math.round(                    /t.length)    // Rounds sum of previous char codes, divides by position + 1
       eval(                       )              // evals string of char codes seperated with +
            (                ).join`+`            // joins previous char codes with +
             t=a.slice(0,++i)                     // creates an array with all the char codes

Si les fonctions ne sont pas autorisées:

alert(String.fromCharCode(...[for(i of prompt())i.charCodeAt()].map((l,i,a)=>Math.round(eval((t=a.slice(0,++i)).join`+`)/t.length))))

_{133 octets}

Extrait ES5:

function _toConsumableArray(r){if(Array.isArray(r)){for(var e=0,t=Array(r.length);e<r.length;e++)t[e]=r[e];return t}return Array.from(r)}function _taggedTemplateLiteral(r,e){return Object.freeze(Object.defineProperties(r,{raw:{value:Object.freeze(e)}}))}var _templateObject=_taggedTemplateLiteral(["+"],["+"]),f,t=function t(s){return String.fromCharCode.apply(String,_toConsumableArray(function(){var r=[],e=!0,t=!1,a=void 0;try{for(var n,i=s[Symbol.iterator]();!(e=(n=i.next()).done);e=!0){var o=n.value;r.push(o.charCodeAt())}}catch(l){t=!0,a=l}finally{try{!e&&i["return"]&&i["return"]()}finally{if(t)throw a}}return r}().map(function(l,i,a){return Math.round(eval((f=a.slice(0,++i)).join(_templateObject))/f.length)})))};

// Demo
document.getElementById('go').onclick=function(){
  document.getElementById('output').innerHTML = t(document.getElementById('input').value)
};

<div style="padding-left:5px;padding-right:5px;"><h2 style="font-family:sans-serif">Average of Words Snippet</h2><div><div  style="background-color:#EFEFEF;border-radius:4px;padding:10px;"><input placeholder="Text here..." style="resize:none;border:1px solid #DDD;" id="input"><button id='go'>Run!</button></div><br><div style="background-color:#EFEFEF;border-radius:4px;padding:10px;"><span style="font-family:sans-serif;">Output:</span><br><pre id="output" style="background-color:#DEDEDE;padding:1em;border-radius:2px;overflow-x:auto;"></pre></div></div></div>

Python 2, 106 octets

Ce n'est pas assez court. Comme c'est python, c'est beaucoup trop verbeux, vous pouvez même lire ce qu'il fait en regardant du code. Mais ça marche.

a=[.0]+[ord(i)for i in raw_input()]
print"".join([chr(int(.5+(sum(a[:i+1])/i)))for i in range(1,len(a))])

Matlab, 43

Utilisation d'une fonction anonyme:

f=@(s)char(round(cumsum(+s)./(1:numel(s))))

Exemples:

>> f=@(s)char(round(cumsum(+s)./(1:numel(s))))
f = 
    @(s)char(round(cumsum(+s)./(1:numel(s))))

>> f('Hello!')
ans =
HW^adY

>> f('test')
ans =
tmop

>> f('42')
ans =
43

>> f('StackExchange')
ans =
Sdccd_ccccddd

JavaScript ES6, 111 octets

w=>w.replace(/./g,(_,i)=>String.fromCharCode([for(f of w.slice(0,++i))f.charCodeAt()].reduce((a,b)=>a+b)/i+.5))

C'est énormément long, en partie grâce au long String.fromCharCodeet aux charCodeAtfonctions de JavaScript . L'extrait de pile contient du code testable non golfé, commenté.

f=function(w){
  return w.replace(/./g,function(e,i){
    return String.fromCharCode(w.slice(0,++i).split('').map(function(f){
      return f.charCodeAt()
    }).reduce(function(a,b){
      // Adds all numbers in the array
      return a+b
      // String.fromCharCode automatically floors numbers, so we add .5 to round up
    })/i+.5)
  })
}

run=function(){document.getElementById('output').innerHTML=f(document.getElementById('input').value)};document.getElementById('run').onclick=run;run()

<input type="text" id="input" value="Hello!" /><button id="run">Run</button><br />
<pre id="output"></pre>

Facteur, 80 octets

[ cum-sum [ dup zero? 1 0 ? + / ] map-index [ .5 + floor >fixnum ] map >string ]