Właśnie zostałeś zatrudniony przez niemiecką firmę produkującą samochody. Twoim pierwszym zadaniem, jako inżyniera, jest napisanie programu obliczającego ślad ekologiczny ciągów ASCII.

Ekologiczny ślad charakteru oblicza się w następujący sposób:

Wpisz kod ASCII znaku w formacie binarnym i policz liczbę 1.

Na przykład Ama ślad 2, ale Ojest bardziej brudny z śladem 5.

Globalny ślad łańcucha jest sumą śladów jego znaków. Pusty ciąg ma zerowy ślad.

Twój program musi zaakceptować ciąg ASCII jako parametr (poprzez wiersz poleceń lub dane wejściowe), obliczyć swój ślad ekologiczny i wyprowadzić go. Sam program musi być zakodowany w ASCII.

Jest jednak czkawka. Ponieważ Twoja firma chce wejść na nowy rynek z bardziej surowymi zasadami ochrony środowiska, musisz dostroić swój program, aby zachowywał się inaczej w „trybie testowym”. A zatem:

Program powinien wypisać 0, gdy otrzyma ciąg testjako parametr.

Punktacja

Wygrywa kod źródłowy o najmniejszym śladzie ekologicznym (i tak, odpowiedź testjest zabroniona!)

CJam, 33 31

"",AA#b:c~

Istnieje 11300000000950000000034000000011600000001010000000115000000011600000000340000000061000000003300000042000000005800000001050000005000000000010000000980000000049000000010200000000980000000049000000000000004900000001020000000098000000004900000000000000490000000102000000009800000000490000000000000049000000010200000000980000000049000000000000000000000000010200000000980000000000000000000000000000000000010200000000980000000000

Kod jest równoważny z

11300000000950000000034000000011600000001010000000115000000011600000000340000000061000000003300000000420000000058000000010500000000500000000102000000009800000000490000000102000000009800000000490000000098
AA#b:c~

które można przetestować online .

Jak to działa

"",  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.

Jak to działa

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.

Ten kod źródłowy ma ślad ekologiczny 75.

Lenguage , 0

Wyjście jest jednoargumentowe , ponieważ Lenguage / Brainfuck nie ma zdrowego sposobu drukowania liczb całkowitych w bazie 10.

Rzeczywisty kod źródłowy zawiera

22360559967824444567791709913713659826044558304969374451791514225490473373040212332757409553558758107085015797320276213515502796255082717802632399123502087743818475438512153373406931103005017157351410347278489842099128517039634739852783737052963203448945756470632484148121769939122103257063633371522287190530269279693540898545359211009781370158317748609540216376596783541124510013448091325488601732964773653391702083563797082990404753843419895799343996435988722965711513708742853668363743953430527328863418281733901770990932025503662188187254784985474815936854540100376410040743052620419372327997519047616042603909398552951490180076364164838561112002025592431155898041427468731461614504254168899805662501979953318388813759833797929243626668399650485310047043700001093878284174322463350892654886806075148010832042248607926124030339950499631072150856939786062937034833055717723216663269161130154002679878012158315587925933383341827053312086716181702533743607685576475754259877651521989944802973721727159955208722180232955193930065862370838526521351991966172723976565264862909528310162816593997640732796289501819499741414526385058421824690665542546821941125191276568479078107133076037506211133628962099403163812267452274532219562823184225236020523509355625620557197876838014050964240952738109101849512504021041103516630358995290177306585560988278630098667702211916671663291473843258785929522017507744814910480115446168939335008597569919072874897148594826036210511162928991890818427747059833051607455121463371211282760364668765311589329918870071117807132901910082663054895226456039171170783440772764031568108965851688162729239711772886386306884508520204834432674839183166053019421652064937613583258148354531835035461504442885024563141848164279928769795684221364984104923764359842286827870778678989243517189772102669283996930513577004801536579491093711362942690905779844535371088542020595945700544234301668098553671685123172583259206072965508639556627967633275762621813851479909708616154198658896714629908456913467267354690109885368211752176196164620615081464122410029328694509842558492529684841818953632659248840216891072110853731776562597900145806210691868173380612838327841104919352821441230296200143603175486627682007399030356592930049570084097858148122367

zero bajtów i jest równoważne z następującym programem Brainfuck:

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

Wypróbuj online na brainfuck.tk .

Długość kodu Brainfuck jest bardzo nieoptymalna - na początek zakodowałem na stałe ślady wszystkich znaków ASCII - ale wynik 0 to wynik 0 ...

PowerShell, 337 344 304 punkty

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

_{RUSZAM SIĘ DO CIEBIE, PONIEWAŻ TANIEJ!}

Pobiera dane wejściowe jako $A, następnie rzutuje jako tablicę znaków, a następnie iteruje pętlę for dla każdego znaku, używa absurdalnie trudnego [convert]::ToString()do przekształcenia znaku w tej pozycji na binarny, zastępuje wszystkie zera niczym, a następnie liczy długość i dodaje to do $B. Na koniec używa równoważności do indeksowania do tablicy dynamicznej (tzn. Jeśli $Ajest test, to -CEQjest $TRUE, więc indeksuje do drugiego elementu 0).

Edit1 - Poprawiony przypadek testowy "TEST"
Edit2 - Grał w golfa kilka punktów, iterując same postacie, a nie ich wskaźniki, i pamiętając, że -replacenie potrzebuje drugiego parametru, jeśli zastępujesz go niczym.

Pyth - 52 49

Trzy punkty oszczędzają dzięki @orlp.

*/.BQ`1nQ"test

Pobiera dane wejściowe w cudzysłowach, aby zaoszczędzić powierzchnię.

Pakiet testowy .

Common Lisp, 294 281 235

Aby obniżyć wynik, użyłem @(koszt 1) i !(koszt 2) jako nazw zmiennych (edytuj: i jeszcze lepiej, jeśli użyję @dla zmiennej występującej najczęściej w funkcji). I krzyczę TOO ponieważ jest tańszy.

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

Całkiem drukowane

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

JavaScript, 279

Edytuj poprawkę błędu (nie liczono bitu 1 każdego znaku)

Kompletny program, z wejściem i wyjściem przez wyskakujące okienko. Testowany w przeglądarce Firefox powinien działać w dowolnej nowoczesnej przeglądarce.

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

Niektóre narzędzia (testowane z Firefoksem)

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]))

count_onesFunkcja zlicza liczbę jedynek w binarnej reprezentacji swojego wejścia.

Zredukowałem mój ślad ekologiczny dzięki 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@@

Wymień wszystkie @z\0

Przykład użycia:

perl -p entry.pl entry.pl

MATLAB, 198 194 bajtów

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

Najpierw ciąg jest odczytywany ze STDIN przez inputfunkcję. Gdy to nastąpi, porównujemy ciąg wejściowy z ciągiem test. Jeśli wynik nie jest test , konwertujemy każdy znak na jego kod ASCII, a następnie jego reprezentację binarną poprzez dec2bin. Piękną konsekwencją tej funkcji jest to, że jeśli prześlesz ciąg znaków, binarna reprezentacja jego kodu ASCII jest ograniczona jednym znakiem w wierszu.

Jako przykład:

>> dec2bin('ABCD')

ans =

1000001
1000010
1000011
1000100

dec2binwyprowadza tablicę znaków. Gdy to się stanie, odejmij 48, czyli kod ASCII dla 0, aby macierz została przekonwertowana na doubleskładającą się z zer i jedynek. Gdy to nastąpi, wezwanie do nnzzliczenia całkowitej liczby niezerowych elementów w tej macierzy. Zauważ, że ten wynik jest mnożony przez przeciwieństwo łańcucha w porównaniu z test. Powinien ciąg nie będzie test, otrzymamy obliczenie powierzchni postojowej. Jeśli jest równy, to mnożenie daje 0.

Kilka przykładów:

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

Grzmotnąć 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

Całkiem proste. Zapętla znaki na wejściu konwertując najpierw na ascii (z printf %di 'na początku liczby, a następnie na binarne (z bc), usuwa zera i zlicza liczbę znaków.

Nie jest to świetna odpowiedź, ale jeszcze nie widziałem próby uderzenia.

Zmodyfikowany od czasu mojej pierwszej odpowiedzi pozwolił na podanie ciągu wejściowego po prostu w wierszu poleceń (tzn. Stał się wieloma parametrami wejściowymi, jeśli wiele słów), ale po przeczytaniu innych odpowiedzi myślę, że mogę założyć, że jest cytowany, więc cały ciąg jest $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});}

To był oryginalny, nie golfisty:

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!");
     }
}

To pobiera argument z parametru wiersza poleceń ... proces.arguments jest (być może pustą) sekwencją ciągów, więc przed użyciem jednego z nich musimy sprawdzić, czy rzeczywiście istnieje. W innym przypadku wysyłamy komunikat o błędzie (nie jest to wymagane przez pytanie i zostanie wyrzucone w następnych wersjach).

sumFunkcja Cejlonu przyjmuje niepustą iterowalną część jakiegoś typu, który musi spełniać Summable, tj. Ma plusmetodę taką jak Liczba całkowita. (Nie działa z pustymi sekwencjami, ponieważ każdy typ Summable będzie miał swoje własne zero, a środowisko wykonawcze nie ma szansy dowiedzieć się, który z nich jest przeznaczony).

Elementy łańcucha lub jednego bitu liczby całkowitej nie są niepustą iterowalną. Dlatego używamy tutaj funkcji do zbudowania iterowalności poprzez określenie niektórych elementów, a następnie „zrozumienia” (które zostanie ocenione na zero lub więcej elementów). Tak więc w przypadku znaku dodajemy je (ale tylko wtedy, gdy ustawiony jest odpowiedni bit), w przypadku ciągu dodajemy wynik znaków. (Zrozumienie zostanie ocenione tylko wtedy, gdy funkcja odbiorcza faktycznie się nad nim iteruje, a nie podczas budowania Iterable).

Zobaczmy, jak możemy to zmniejszyć. Po pierwsze, każda z funkcji jest wywoływana tylko w jednym miejscu, więc możemy je wstawić. Ponadto, jak wspomniano powyżej, pozbyć się komunikatu o błędzie. (764 punktów śladu).

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 }) }));
        }
    }
}

Tak naprawdę nie potrzebujemy zagnieżdżenia wewnętrznego sum, możemy to jedno wielkie zrozumienie. (To oszczędza nam 37 punktów śladu sum({0,}), a trochę więcej dla białych znaków, które i tak zostaną wyeliminowane na końcu.) To jest 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 }));
        }
    }
}

Możemy zastosować podobną zasadę do specjalnego "test"ciągu w postaci łańcucha: ponieważ w tym przypadku wynik wynosi 0 (tzn. Nic nie jest sumowane), możemy to zrobić tylko jako część sumy (ale musimy odwrócić warunek) . To głównie oszczędza nam print(0);trochę nawiasów klamrowych i kilka wcięć, dochodząc do 571:

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 }));
    }
}

Robimy to samo za pierwszym razem if, z efektem ubocznym, który teraz nie daje żadnych argumentów, a także 0nic nie robi. (Przynajmniej myślałem, że tak się stanie tutaj, zamiast tego wydaje się, że zawiesi się w wiecznej pętli? Dziwne.)

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 }));
}

Możemy faktycznie pominąć tutaj funkcję ()dla tej sumfunkcji, używając alternatywnej składni wywołania funkcji , która używa {...}zamiast tego ()i wypełni wyrażenia w iterowalnych argumentach. Ma to ślad 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 });
}

Zastąpienie nazwy funkcji footprint(40) przez p(3) pozwala zaoszczędzić kolejne 37 punktów, co prowadzi do 501. (Nazwy funkcji Cejlonu muszą zaczynać się od małych liter, więc nie możemy uzyskać tutaj mniej niż 3 punkty).

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 });
}

Nazwy zmiennych s(5) i c(4), i(4) również nie są optymalne. Zamieńmy je na a(argument), d(cyfra?) I b(indeks bitów). Ślad 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 });
}

Nie widzę żadnej optymalizacji spoza białych znaków, więc usuń niepotrzebne spacje (1 punkt za każde miejsce, dwa za każde z dwóch podziałów linii):

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});}

Podczas przeglądania interfejsu API odkryłem, że Character.hash faktycznie zwraca tę samą wartość co jego integeratrybut. Ale ma tylko 14 punktów zamiast 30, więc schodzimy do 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"]

edytuj - zapomniałem przypadku „testowego” ... tak drogiego.

editedit - przegapiłem okazję DUŻA.

editeditedit - uwzględnił sugestie dotyczące komentarzy (dzięki TimmyD).

edycja 4 - D jest tańszą odmianą niż C (2 vs. 3)

edycja 5 - Powrót do 295 ze względu na sprawdzanie wielkości liter.

Pętle przechodzą przez ciąg znaków i zliczają jedynki, które są przesunięte względem wartości ASCII znaków.

Porada dla TimmyD za przekazanie mi przewidywania, aby używać wielkich liter ORAZ na końcu używać indeksu tablicy.

Matlab, 320

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

C 374

Dodano nowe linie (nie uwzględnione w wyniku) dla zachowania przejrzystości. Można go poprawić do 360, zmieniając nazwy zmiennych na wielkie, ale postaram się wymyślić coś lepszego.

Dane wejściowe są wprowadzane za pomocą wiersza polecenia, co oznacza, że ​​powoduje awarie w przypadku nieobecności danych wejściowych. Oczekuję gorszego wyniku dla wejścia poprzez 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 Ślad ekologiczny (wciąż dużo) , 102 91 bajtów

Wydaje się, że PHP jest przyjazny środowisku tylko w trybie testowym. ;)

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

Działa z wiersza poleceń, takich jak:

php footprint.php hello
php footprint.php test

whilejest bardziej przyjazny dla środowiska, fornawet jeśli mają tę samą liczbę znaków. Również nazwy zmiennych pisane wielkimi literami mają lepszy ślad niż ich odpowiedniki pisane małymi literami.

Edytować

• zapisano 40 punktów, używając nazw funkcji pisanych wielkimi literami.
• zaoszczędził 38 punktów, używając decbinzamiastbase_convert

VBA, 475 418

Dzięki Jacob za 57 punktów zniżki

• Konwertuje ciąg na tablicę bajtów (128 to skrót vba dla „Konwertuje ciąg z Unicode na domyślną stronę kodową systemu”, więc nie będzie działać na Macu ....)

• Pętle przetwarzają tablicę bajtów na binarną i łączą wszystko razem.

• sprawdza test
• Wyświetla długość łańcucha, a wszystkie zera są zastępowane niczym

VBA, dlaczego jesteś taki zły w golfie ... :(

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

Sprawdza, czy dane wejściowe są testowe, a jeśli nie, liczy liczbę 1 w binarnej reprezentacji danych wejściowych.

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

Nie ma tu nic do powiedzenia: zamień każdą postać w wartość ascii ( fromEnum) i oblicz 1s (via a). Zsumuj wszystkie wyniki.

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)

To moja pierwsza próba gry w golfa w JavaScript, więc prawdopodobnie jest bardzo nie golfa.

Rubin, 316 313

Bardzo proste, szukając więcej możliwości gry w golfa:

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

• Używany bzamiast, xaby zapisać 3 punkty.

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

Port mojej odpowiedzi na Pythona powyżej.

Dane wejściowe są odbierane jako ciąg (z cudzysłowami):

"ABC"

CJam, 123

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

Pyth, 96

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

Port mojej odpowiedzi CJam, powyżej / poniżej.

CJam, 83 81 79 77

Jak dotąd najlepszy po wypróbowaniu wielu odmian:

l0$"test"=!\:i2fbe_1b*

Wypróbuj online

Wyjaśnienie:

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

Proste przejście przez wszystkie bajty wejścia i wszystkie bity w każdym bajcie, zsumowane do zmiennej d.

djest inicjowany na -2, ponieważ hzawiera kończący znak nowej linii od wartości wejściowej (wart 2 bity) i nie chcemy tego liczyć.

Podobnie hbędzie zawierać testkońcowy znak nowej linii, więc nowy wiersz musi zostać uwzględniony w wartości porównania.

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))))

Dość oczywiste.
Testy:

> 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, ślad 378, 98 bajtów

Inne rozwiązanie C:

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);}

Działa to tak, że s jest zazwyczaj inicjowane na 0, ale staje się -17, jeśli argument wiersza poleceń to „test” (strcmp zwraca 0 dla równych ciągów, a niezerowe dla różnych ciągów, więc odwrócenie daje 1, jeśli ciąg to „test”). Liczba -17 została wybrana, aby zrekompensować powierzchnię 17, która zostanie obliczona dla „testu”. Obliczanie powierzchni postojowej jest łatwe dzięki operatorom bitowym.

Kłapnięcie! Początkowo brakowało mi „najkrótszych wygranych footprintów”, więc dążyłem do uzyskania najkrótszego kodu ... Zobaczę, czy mogę zmniejszyć „footprint”.

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 nie jest bardzo zielona.

Wersja bez golfa:

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);
    }
}

Djest zadeklarowany jako Integertaki, abyśmy mogli uzyskać dostęp do metody Integerstatycznej bitCountw sposób przyjazny dla środowiska. bitCountSposób traktuje charS jako liczby całkowite i zwraca liczbę ustawionych bitów.