Sie wurden gerade von einem deutschen Automobilhersteller eingestellt. Ihre erste Aufgabe als Ingenieur ist es, ein Programm zu schreiben, das den ökologischen Fußabdruck von ASCII-Zeichenfolgen berechnet.

Der ökologische Fußabdruck des Charakters wird wie folgt berechnet:

Schreiben Sie den ASCII-Code des Zeichens binär und zählen Sie die Anzahl der Einsen.

Hat beispielsweise Aeine Grundfläche von 2, ist jedoch Omit einer Grundfläche von 5 schmutziger.

Der globale Footprint eines Strings ist die Summe der Footprints seiner Zeichen. Eine leere Zeichenfolge hat einen Footprint von Null.

Ihr Programm muss einen ASCII-String als Parameter akzeptieren (über die Befehlszeile oder Eingabe), seinen ökologischen Fußabdruck berechnen und ausgeben. Das Programm selbst muss ASCII-codiert sein.

Es gibt jedoch einen Schluckauf. Da Ihr Unternehmen in einen neuen Markt mit strengeren Umweltvorschriften eintreten möchte, müssen Sie Ihr Programm so einstellen, dass es sich im "Testmodus" anders verhält. Somit:

Das Programm sollte 0 ausgeben, wenn es den String testals Parameter empfängt .

Wertung

Der Quellcode mit dem geringsten ökologischen Fußabdruck gewinnt (und ja, die Antwort testist verboten!)

CJam, 33 31

"",AA#b:c~

Es gibt 113000000009500000000340000000116000000010100000001150000000116000000003400000000610000000033000000004200000000000000000000000000000000000000000000000000000000000000000000000000000000000000 zwischen den.

Der Code ist äquivalent zu

11300000000950000000034000000011600000001010000000115000000011600000000340000000061000000003300000000420000000058000000010500000000500000000102000000009800000000490000000102000000009800000000490000000098
AA#b:c~

das kann online getestet werden .

Wie das geht

"",  e# Push the length of the string.
AA#  e# Push 10000000000.
b    e# Turn the length into the array of its base-10000000000 digits.
:c   e# Cast each digit to character. This pushes the following:
     e# q_"test"=!*:i2fb1fb1b
~    e# Evaluate the string.

Wie das funktioniert

q_     e# Read all input and push a copy.
"test" e# Push the string "test".
=!*    e# Check for inequality and repeat the string 0 or 1 times.
       e# This replaces input "test" with the empty string.
:i     e# Cast each character to integer
2fb    e# Replace each integer by the array of its base-2 digits.
1fb    e# Replace each array of base-2 digits by the sum of its digits.
1b     e# Add the sums of digits.

Dieser Quellcode hat einen ökologischen Fußabdruck von 75.

Sprache , 0

Die Ausgabe erfolgt in einstelligen , da Lenguage / Brainfuck keine vernünftige Art und Weise hat ganze Zahlen von Druck in der Basis 10.

Der eigentliche Quellcode enthält

22360559967824444567791709913713659826044558304969374451791514225490473373040212332757409553558758107085015797320276213515502796255082717802632399123502087743818475438512153373406931103005017157351410347278489842099128517039634739852783737052963203448945756470632484148121769939122103257063633371522287190530269279693540898545359211009781370158317748609540216376596783541124510013448091325488601732964773653391702083563797082990404753843419895799343996435988722965711513708742853668363743953430527328863418281733901770990932025503662188187254784985474815936854540100376410040743052620419372327997519047616042603909398552951490180076364164838561112002025592431155898041427468731461614504254168899805662501979953318388813759833797929243626668399650485310047043700001093878284174322463350892654886806075148010832042248607926124030339950499631072150856939786062937034833055717723216663269161130154002679878012158315587925933383341827053312086716181702533743607685576475754259877651521989944802973721727159955208722180232955193930065862370838526521351991966172723976565264862909528310162816593997640732796289501819499741414526385058421824690665542546821941125191276568479078107133076037506211133628962099403163812267452274532219562823184225236020523509355625620557197876838014050964240952738109101849512504021041103516630358995290177306585560988278630098667702211916671663291473843258785929522017507744814910480115446168939335008597569919072874897148594826036210511162928991890818427747059833051607455121463371211282760364668765311589329918870071117807132901910082663054895226456039171170783440772764031568108965851688162729239711772886386306884508520204834432674839183166053019421652064937613583258148354531835035461504442885024563141848164279928769795684221364984104923764359842286827870778678989243517189772102669283996930513577004801536579491093711362942690905779844535371088542020595945700544234301668098553671685123172583259206072965508639556627967633275762621813851479909708616154198658896714629908456913467267354690109885368211752176196164620615081464122410029328694509842558492529684841818953632659248840216891072110853731776562597900145806210691868173380612838327841104919352821441230296200143603175486627682007399030356592930049570084097858148122367

null Bytes und entspricht dem folgenden Brainfuck-Programm:

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

Probieren Sie es online auf brainfuck.tk .

Die Länge des Brainfuck-Codes ist höchst suboptimal - für den Anfang habe ich die Fußabdrücke aller ASCII-Zeichen fest codiert - aber Punktzahl 0 ist Punktzahl 0 ...

PowerShell, 337 344 304 Punkte

PARAM([CHAR[]]$A)$A|%{$B+=([CONVERT]::TOSTRING(+$_,2)-REPLACE0).LENGTH};($B,0)[-JOIN$A-CEQ"test"]

_{Ich rufe dich an, weil es billiger ist!}

Nimmt die Eingabe als $A, wandelt sie dann als Zeichen-Array um, durchläuft dann eine for-Schleife für jedes Zeichen, [convert]::ToString()konvertiert das Zeichen an dieser Position mit lächerlich wortreichen Worten in binäre Zeichen, ersetzt alle Nullen durch nichts und zählt dann die Länge und fügt das hinzu $B. Verwendet am Ende eine Äquivalenz, um ein dynamisches Array zu indizieren (dh, wenn es $Aist test, dann -CEQist es $TRUEso, dass es auf das zweite Element indiziert 0).

Edit1 - Korrigierter Testfall "TEST"
Edit2 - Golf ein paar Punkte durch Iteration über die Zeichen selbst und nicht über ihre Indizes, und indem Sie sich daran erinnern, dass Sie -replacekeinen zweiten Parameter benötigen, wenn Sie ihn durch nichts ersetzen.

Pyth - 52 49

Drei Punkte sparen dank @orlp.

*/.BQ`1nQ"test

Nimmt Eingaben in Anführungszeichen vor, um Platz zu sparen.

Test Suite .

Gemeines Lisp, 294 281 235

Um die Punktzahl zu verringern, habe ich @(Kosten 1) und !(Kosten 2) als Variablennamen verwendet (Bearbeiten: und es ist noch besser, wenn ich @für die Variable verwende, die in der Funktion am häufigsten vorkommt). ICH SCHREIE TOO , weil es billiger ist.

(LAMBDA(@)(IF(STRING="test"@)0(LOOP FOR ! ACROSS @ SUM(LOGCOUNT(CHAR-CODE !)))))

Hübsch bedruckt

(LAMBDA (@)
  (IF (STRING= "test" @) 0
      (LOOP FOR ! ACROSS @ SUM (LOGCOUNT (CHAR-CODE !)))))

JavaScript, 279

Fehlerbehebung bearbeiten (Bit 1 jedes Zeichens wurde nicht gezählt)

Ein komplettes Programm mit Ein- und Ausgabe über Popup. Getestet in Firefox, sollte in jedem modernen Browser funktionieren.

B=(P=prompt)(H=D=0)
while(B!="test"&&(A=B.charCodeAt(H++)))while(A)D+=A&1,A>>=1
P(D)

Einige Tools (Getestet mit Firefox)

w=c=>c.toString(2).split('').reduce(function(a,b){return a- -b})

t=[[],[],[],[],[],[],[],[],[]]
u=[[],[],[],[],[],[],[],[],[]]
for(c=1;c<256;c++)
  c<33|c>126&c<161 ? t[w(c)].push('\\'+c) : u[w(c)].push('&#'+c+';')
for(i=0; i++<8;)       
  T.innerHTML+=i+': '+u[i].concat(t[i]).join(' ')+'\n'

function Calc()
{
  var r='', t=0, b
  I.value.split('').forEach(function(c) {
    c = c.charCodeAt(), r += '\n&#'+c+' '+((256+c).toString(2).slice(1))+' : '
    for(b=0;c;c>>=1) b += c&1
    r += b, t += b
  })
  R.innerHTML='Total '+t+'\nDetail'+r
}

#I { width: 400px }

<b>Weight table</b><pre id=T></pre><br>
<b>Counter</b><br><textarea id=I></textarea><button onclick="Calc()">-></button> <pre id=R></pre>

Julia, 254 246 232

P=readline()
print(P=="test"?0:sum([count_ones(1*A)for A=P]))

Die count_onesFunktion zählt die Anzahl der Einsen in der Binärdarstellung ihres Eingangs.

Reduzierte meinen ökologischen Fußabdruck dank FryAmTheEggman!

Python 3, 271

z=input();print([sum([bin(ord(i)).count("1")for i in z]),0][z=="test"])

Perl, 136, 118, 73

$_=unpack"B*";$_=y@1@@

Ersetzen Sie alle @durch\0

Anwendungsbeispiel:

perl -p entry.pl entry.pl

MATLAB, 198 194 Bytes

A=input('','s');~strcmp('test',A)*nnz(dec2bin(A)-48)

Zunächst wird der String über die inputFunktion aus STDIN eingelesen . In diesem Fall vergleichen wir die Eingabezeichenfolge mit der Zeichenfolge test. Wenn das Ergebnis nicht test stimmt, konvertieren wir jedes Zeichen in seinen ASCII-Code und dann in seine Binärdarstellung über dec2bin. Eine schöne Folge dieser Funktion ist, dass die binäre Darstellung des ASCII-Codes durch ein Zeichen pro Zeile begrenzt wird, wenn Sie eine Zeichenfolge übergeben.

Als Beispiel:

>> dec2bin('ABCD')

ans =

1000001
1000010
1000011
1000100

dec2bingibt ein Zeichenarray aus. Subtrahieren Sie in diesem Fall den ASCII-Code für 0 mit 48, damit die Matrix in double0 und 1 konvertiert wird . Sobald dies geschieht, wird ein Aufruf zum nnzAufzählen der Gesamtzahl der von Null verschiedenen Elemente in dieser Matrix ausgeführt. Beachten Sie, dass dieses Ergebnis mit dem Gegenteil der Zeichenfolge multipliziert wird, mit der verglichen wird test. Sollte der String nicht sein test, erhalten wir die Footprint-Berechnung. Wenn es gleich ist, ergibt die Multiplikation 0.

Einige Beispiele:

>> A=input('','s');~strcmp('test',A)*nnz(dec2bin(A)-48)
A

ans =

     2

>> A=input('','s');~strcmp('test',A)*nnz(dec2bin(A)-48)
O

ans =

     5

>> A=input('','s');~strcmp('test',A)*nnz(dec2bin(A)-48)
test

ans =

     0


>> A=input('','s');~strcmp('test',A)*nnz(dec2bin(A)-48)
  %// Note - no characters were added here.  Simply pushed Enter

ans =

     0

Bash 440 430 412 405 403

A=0
[ test != "$1" ]&&for((D=0;D<${#1};D++)){
A=$((A+`bc<<<$(printf "obase=2;%d" "'${1:$D:1}")|tr -d "0
"|wc -m`))
}
echo $A

Ziemlich einfach. Schleifen von Zeichen in der Eingabe, die zuerst in ASCII konvertiert werden (mit printf %dund dem führenden Zeichen in der 'Zahl, dann in binär (mit bc), entfernen die Nullen und zählen die Anzahl der Zeichen.

Keine gute Antwort, hatte aber noch keinen Bash-Versuch gesehen.

Geändert, seit meine erste Antwort erlaubte, dass der Eingabe-String einfach auf der Kommandozeile angegeben wurde (dh es wurden mehrere Eingabe-Parameter, wenn Wörter mit mehreren Ausdrücken geschrieben wurden), aber nachdem ich einige andere Antworten gelesen habe, kann ich davon ausgehen, dass der gesamte String in Anführungszeichen steht $1

Ceylon, 1431 , 764 , 697 , 571 , 547 , 538 , 501 , 493 , 467 , 451

shared void p(){print(sum{0,if(exists a=process.arguments[0])if(a!="test")for(c in a)for(b in 0..7)if(c.hash.get(b))1});}

Dies war das Original, ungolfed:

Integer footprintCharacter(Integer b) {
    return sum({0, for(i in 0..7) if(b.get(i)) 1 });
}
Integer footPrintString(String s) {
    if(s == "test") {return 0;}
    return sum({0, for(c in s) footprintCharacter(c.integer)});
}
shared void footprint() {
     if(exists s = process.arguments[0]) {
         print(footPrintString(s));
     } else {
         print("This program needs at least one parameter!");
     }
}

Das Argument stammt aus einem Befehlszeilenparameter ... process.arguments ist eine (möglicherweise leere) Folge von Zeichenfolgen. Bevor Sie eine dieser Zeichenfolgen verwenden, müssen Sie überprüfen, ob sie tatsächlich vorhanden sind. Im anderen Fall geben wir eine Fehlermeldung aus (diese wird von der Frage nicht benötigt und wird in den nächsten Versionen weggeworfen).

Ceylons sumFunktion nimmt eine nicht leere Iterable von Elementen eines Typs an, die erfüllt sein müssen Summable, dh eine plusMethode wie Integer haben müssen. (Es funktioniert nicht mit leeren Sequenzen, da jeder Summable-Typ eine eigene Null hat und die Laufzeit keine Chance hat, zu wissen, welche gemeint ist.)

Die Elemente einer Zeichenfolge oder die Bits einer Ganzzahl sind keine nicht leeren iterierbaren Elemente. Aus diesem Grund verwenden wir hier die Funktion, um eine Iteration zu erstellen, indem Sie einige Elemente und dann ein "Verständnis" angeben (das mit null oder mehr Elementen bewertet wird). Im Zeichenfall addieren wir also Einsen (aber nur, wenn das entsprechende Bit gesetzt ist), im Zeichenfall addieren wir das Ergebnis der Zeichen. (Das Verständnis wird nur bewertet, wenn die Empfangsfunktion tatsächlich darüber iteriert, nicht wenn die Iterable erstellt wird.)

Mal sehen, wie wir das reduzieren können. Erstens wird jede der Funktionen nur an einer Stelle aufgerufen, damit wir sie einbinden können. Beseitigen Sie auch, wie oben erwähnt, die Fehlermeldung. (764 Footprint-Punkte.)

shared void footprint() {
    if (exists s = process.arguments[0]) {
        if (s == "test") {
            print(0);
        } else {
            print(sum({ 0, for (c in s) sum({ 0, for (i in 0..7) if (c.integer.get(i)) 1 }) }));
        }
    }
}

Wir brauchen das Verschachtelte nicht wirklich sum, wir können dies zu einem großen Verständnis machen. (Dies erspart uns 37 Footprint-Punkte sum({0,})und noch mehr für Whitespace, was am Ende sowieso beseitigt wird.) Dies ist 697:

shared void footprint() {
    if (exists s = process.arguments[0]) {
        if (s == "test") {
            print(0);
        } else {
            print(sum({ 0, for (c in s) for (i in 0..7) if (c.integer.get(i)) 1 }));
        }
    }
}

Wir können ein ähnliches Prinzip auf die Sonderzeichenfolge anwenden "test": Da in diesem Fall das Ergebnis 0 ist (dh es wird nichts zur Summe beigetragen), können wir dies nur als Teil der Summierung tun (aber wir müssen die Bedingung invertieren). . Dies erspart uns hauptsächlich die print(0);, einige Klammern und eine Reihe von Einrückungsräumen, die sich auf eine Stellfläche von 571 reduzieren:

shared void footprint() {
    if (exists s = process.arguments[0]) {
        print(sum({ 0, if (s != "test") for (c in s) for (i in 0..7) if (c.integer.get(i)) 1 }));
    }
}

Das Gleiche machen wir zum ersten Mal if, mit dem Nebeneffekt, dass jetzt kein Argument mehr ausgegeben wird, 0anstatt nichts zu tun. (Zumindest dachte ich, dass das hier passieren würde, stattdessen scheint es mit einer ewigen Schleife zu hängen? Seltsam.)

shared void footprint() {
    print(sum({ 0, if (exists s = process.arguments[0]) if (s != "test") for (c in s) for (i in 0..7) if (c.integer.get(i)) 1 }));
}

Wir können das ()für die sumFunktion hier weglassen , indem wir eine alternative Funktionsaufrufsyntax verwenden , die {...}anstelle von verwendet wird (), und Verständnis in iterierbare Argumente eintragen. Das hat Footprint 538:

shared void footprint() {
    print(sum{ 0, if (exists s = process.arguments[0]) if (s != "test") for (c in s) for (i in 0..7) if (c.integer.get(i)) 1 });
}

Das Ersetzen des Funktionsnamens footprint(40) durch p(3) spart weitere 37 Punkte und bringt uns auf 501. (Ceylon-Funktionsnamen müssen mit Kleinbuchstaben beginnen, daher können wir hier nicht weniger als 3 Punkte erhalten.)

shared void p() {
    print(sum{ 0, if (exists s = process.arguments[0]) if (s != "test") for (c in s) for (i in 0..7) if (c.integer.get(i)) 1 });
}

Die Variablennamen s(5) und c(4), i(4) sind ebenfalls nicht optimal. Ersetzen wir sie durch a(Argument), d(Ziffer?) Und b(Bit-Index). Stellfläche 493:

shared void p() {
    print(sum{ 0, if (exists a = process.arguments[0]) if (a != "test") for (c in a) for (b in 0..7) if (c.integer.get(b)) 1 });
}

Ich sehe keine verbleibende Nicht-Leerzeichen-Optimierung. Entfernen wir also das nicht benötigte Leerzeichen (1 Punkt für jedes Leerzeichen, zwei für jeden der beiden Zeilenumbrüche):

shared void p(){print(sum{0,if(exists a=process.arguments[0])if(a!="test")for(c in a)for(b in 0..7)if(c.integer.get(b))1});}

Beim Durchsuchen der API stellte ich fest, dass Character.hash tatsächlich denselben Wert wie sein integerAttribut zurückgibt . Aber es hat nur 14 statt 30 Punkte, also kommen wir auf 451!

shared void p(){print(sum{0,if(exists a=process.arguments[0])if(a!="test")for(c in a)for(b in 0..7)if(c.hash.get(b))1});}

PowerShell, 273 336 328 324 293 288 295

PARAM($A)[CHAR[]]$A|%{$D=[INT]$_;WHILE($D){$B+=$D-BAND0X1;$D=$D-SHR1}};($B,0)[$A-CEQ"test"]

edit - habe den "Test" -Fall vergessen ... so teuer.

Bearbeitet - hat eine GROSSBUCHSTABEN-Gelegenheit verpasst.

editeditedit - hat die Kommentarvorschläge aufgenommen (Danke TimmyD).

edit 4 - D ist eine billigere Variable als C (2 vs. 3)

edit 5 - Zurück zu 295 aufgrund der Prüfung der Groß- und Kleinschreibung.

Durchläuft die Zeichenfolge und zählt die Einsen, die vom ASCII-Wert der Zeichen abweichen.

Hut ab vor TimmyD, der mir die Voraussicht gegeben hat, Großbuchstaben UND den Array-Index am Ende zu verwenden.

Matlab, 320

A=(input('','s'));nnz(floor(rem(bsxfun(@times,[A 0],2.^(-7:0)'),2)))*~strcmp(A,'test')

C 374

Zeilenumbrüche (nicht in der Partitur enthalten) wurden der Übersichtlichkeit halber hinzugefügt. Könnte durch Ändern von Variablennamen in Großbuchstaben auf 360 verbessert werden, aber ich werde versuchen, mir etwas Besseres auszudenken.

Die Eingabe erfolgt über die Befehlszeile. Dies bedeutet, dass bei fehlender Eingabe keine Fehler auftreten. Ich erwarte eine schlechtere Bewertung für die Eingabe durch stdin.

i,t;
main(int c,char**v){
for(;c=v[i][i/8];i++)t+=(c>>i%8)&1;
printf("%d",strcmp(v[1],"test")?t:0);
}

PHP, 377 337 299 Ökologischer Fußabdruck (immer noch viel) , 102 91 Bytes

Scheint, dass PHP nur im Testmodus umweltfreundlich ist. ;)

WHILE($D<STRLEN($A=$argv[1]))$B+=SUBSTR_COUNT(DECBIN(ORD($A[$D++])),1);ECHO"test"!=$A?$B:0;

Läuft von der Kommandozeile aus wie:

php footprint.php hello
php footprint.php test

whileist umweltfreundlicher als for, obwohl sie die gleiche Zeichenanzahl haben. Auch Variablennamen in Großbuchstaben haben einen besseren Footprint als die Namen in Kleinbuchstaben.

Bearbeiten

• 40 Punkte durch Verwendung von Funktionsnamen in Großbuchstaben gespeichert.
• sparte 38 Punkte mit decbinanstelle vonbase_convert

VBA, 475 418

Danke Jacob für 57 Punkte

• Konvertiert einen String in ein Byte-Array (128 ist eine vba-Abkürzung für "Konvertiert den String von Unicode in die Standard-Codepage des Systems". Funktioniert also nicht auf einem Mac ....)

• Schleifen durch Byte-Array, das alles in Binär umwandelt und zusammen verkettet.

• prüft auf Test
• Gibt die Länge der Zeichenfolge aus, wobei alle Nullen durch nichts ersetzt werden

VBA, warum bist du so schlecht im Golfen ... :(

SUB A(D)
DIM B() AS BYTE
B=STRCONV(D,128)
FOR P=0 TO UBOUND(B)
H=H+APPLICATION.DEC2BIN(B(P))
NEXT
IF D="test" THEN H=0
MSGBOX LEN(REPLACE(H,0,""))
ENDSUB

JavaScript, 418 410

A=prompt();B=0;!A||A=="test"?0:A.split("").forEach(D=>B+=D.charCodeAt().toString(2).match(/1/g).length);alert(B)

Pyth, 64

?qz"test"0l`sS.Bz

Überprüft, ob es sich bei dem Eingang um einen Test handelt, und zählt, falls nicht, die Anzahl der Einsen in der Binärdarstellung des Eingangs.

Haskell, 292

a 0=0
a b=rem b 2+a(div b 2)
b"test"=0
b d=sum$map(a.fromEnum)d
main=interact$show.b

Hier gibt es nicht viel zu sagen: Verwandle jedes Zeichen in einen ASCII-Wert ( fromEnum) und berechne das 1s (via a). Fassen Sie alle Ergebnisse zusammen.

JavaScript (ES6), 521 478 458 449 473 465

alert(((A=prompt(),A!="test")&&(A!=""))?(A.split``.map(H=>(H.charCodeAt().toString(2).match(/1/g)||[]).length)).reduce((A,B)=>A+B):0)

Dies ist mein erster Versuch mit einem JavaScript-Golf, daher ist es wahrscheinlich sehr ungolfed.

Ruby, 316 313

Sehr unkompliziert und auf der Suche nach weiteren Golfmöglichkeiten:

b=gets.chomp;b=='test'?0:b.chars.map{|i|i.ord.to_s(2).count('1')}.inject(:+)

• Wird bverwendet x, um 3 Punkte zu speichern.

Python 2, 294 281 269 266

A=input()
print sum(format(ord(H),"b").count("1")for H in A)if A!="test"else 0

Ein Port meiner Pyth-Antwort oben.

Die Eingabe wird als Zeichenfolge (mit Anführungszeichen) empfangen:

"ABC"

CJam, 123

q_"test"={;0}{{s2b2b~}%1e=}?

Pyth, 96

Iqz"test"0.q)/j""m.BdmCdz\1

Ein Port meiner CJam-Antwort, oben / unten.

CJam, 83 81 79 77

Am besten bisher, nachdem Sie eine Reihe von Variationen ausprobiert haben:

l0$"test"=!\:i2fbe_1b*

Probieren Sie es online aus

Erläuterung:

l       Get input. Other options like q and r are the same number of bits.
0$      Copy input for comparison. This saves 2 bits over _.
"test"  Push special case string.
=       Compare.
!       Negate so that we have 0 for special case, 1 for normal case.
\       Swap input string to top.
:i      Convert characters to integers.
2fb     Apply conversion to base 2 to all values.
e_      Flatten array.
1b      Sum up the bits. This is 2 bits shorter than :+.
*       Multiply with result from special case test.

Ruby, 247

Einfacher Ansatz, der alle Bytes der Eingabe und alle Bits in jedem Byte durchläuft und zu einer Variablen summiert d.

dwird auf -2 initialisiert, weil es hden abschließenden Zeilenumbruch vom Eingang enthält (Wert 2 Bit) und wir das nicht zählen wollen.

Ebenso hwird testmit einem abschließenden Zeilenumbruch ein Zeilenumbruch enthalten, so dass im Vergleichswert ein Zeilenumbruch enthalten sein muss.

d=-2
h=gets
h.bytes{|a|8.times{|b|d+=a>>b&1}}
p h=='test
'?0:d

R 279

sum(as.integer(rawToBits(charToRaw(if((s=readline())=='test')''else s))))

Ziemlich selbsterklärend.
Tests:

> sum(as.integer(rawToBits(charToRaw(if((s=readline())=='test')''else s))))
sum(as.integer(rawToBits(charToRaw(if((s=readline())=='test')''else s))))
[1] 279
> sum(as.integer(rawToBits(charToRaw(if((s=readline())=='test')''else s))))
A
[1] 2
> sum(as.integer(rawToBits(charToRaw(if((s=readline())=='test')''else s))))
O
[1] 5
> sum(as.integer(rawToBits(charToRaw(if((s=readline())=='test')''else s))))
test
[1] 0
> sum(as.integer(rawToBits(charToRaw(if((s=readline())=='test')''else s))))
OAO
[1] 12

C, 378 Fußabdruck, 98 Bytes

Eine andere C-Lösung:

s;main(c,a)char**a;{for(s=-17*!strcmp(a[1],"test");c=*a[1]++;)for(;c;s+=c&1,c/=2);printf("%d",s);}

Dies funktioniert folgendermaßen: s wird normalerweise mit 0 initialisiert, wird jedoch zu -17, wenn das Befehlszeilenargument "test" lautet (strcmp gibt 0 für gleiche Zeichenfolgen und ungleich Null für unterschiedliche Zeichenfolgen zurück, sodass beim Invertieren 1 für Zeichenfolgen ausgegeben wird ist "test"). Die Zahl -17 wurde gewählt, um den Fußabdruck von 17 zu kompensieren, der für "Test" berechnet wird. Die Berechnung des Footprints ist mit bitweisen Operatoren einfach.

Schnapp! Anfangs habe ich die "kürzesten Footprint-Siege" verpasst, also habe ich den kürzesten Code angestrebt ... Ich werde sehen, ob ich den "Footprint" verkleinern kann.

Java, 594

class A{public static void main(String[]P){Integer D,H;for(D=H=0;D<P[0].length();)H+=D.bitCount(P[0].charAt(D++));System.out.print(P[0].equals("test")?0:H);}}

Java ist nicht sehr grün.

Ungolfed-Version:

class A {
    public static void main(String[]P) {
        Integer D,H;
        for(D=H=0;D<P[0].length();)
            H+=D.bitCount(P[0].charAt(D++));
        System.out.print(P[0].equals("test")?0:H);
    }
}

Dwird als deklariert, Integerdamit wir umweltbewusst auf Integerdie statische bitCountMethode zugreifen können . Die bitCountMethode behandelt das chars als Ganzzahl und gibt die Anzahl der gesetzten Bits zurück.