J (33)

Een lager dan 34!

+/,#:3 u: 

Heavily geïnspireerd door dit antwoord , maar een hamming-gewicht van één lager.

 +/,#:3 u:"+/,#:3 u:" 33 

J, gewicht 34

+/,#:a.i. 

Gebruik – plaats de tekenreeks die moet worden gemeten tussen aanhalingstekens aan het einde:

 +/,#:a.i."+/,#:a.i." 34 

Als alternatief, invoer van het toetsenbord nemen (gewicht 54):

 +/,#:a.i.1!:1[1 hello 21 

Reacties

• Er is ‘ s maar één manier om dit te schrijven:)
• Er is geen ‘ t … Ik heb een oplossing gevonden met een hamming-gewicht van één lager.
• Ik probeer geen buzzkill te zijn, maar de regels vragen om een programma, niet om een fragment.

Python, 189

print sum(bin(ord(A)).count("1")for A in raw_input()) 

Reacties

• Het Python 3-equivalent, print(sum(bin(ord(A)).count('1')for A in input())), heeft een score van 180.
• @ dan04: gebruik dubbele aanhalingstekens in plaats van enkele voor 176.

QBasic, 322 311 286 264

H$=COMMAND$ FOR A=1 TO LEN(H$) B=ASC(MID$(H$,A,1)) WHILE B>0 D=D+B MOD 2 B=B\2 WEND NEXT ?D 

Soort de juiste tool voor de klus, is natuurlijk nog steeds waardeloos.

Reacties

• +1 voor het gebruik van een van mijn favoriete talen aller tijden. Het ‘ is de eerste taal die ik heb leren coderen op een pc.

Unair 0

Jullie wisten allemaal dat het eraan kwam. Eerst het BrainFuck-programma:

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

Ik heb nieuwe regels toegevoegd om het “leesbaar” te maken, maar het heeft een Hamming-gewicht van 4066. Het werkt door herhaaldelijk het quotiënt / restanten van een invoertekenreeks en het optellen van alle restanten. Als je het op zichzelf zou moeten draaien, krijg je natuurlijk: 226 (4066% 256) (technisch \ xe2) dus het is duidelijk dat het zichzelf als winnaar beschouwt.

Nu converteren we het naar Unary en krijgen

000 ... 9*google^5.9 0"s ... 000 

We gebruiken een unaire implementatie met NULL-tekens \ x00 voor “0” en boem, hamming-gewicht van 0.

Bonusvraag : voor welke ASCII-tekens c kun je dit programma uitvoeren op een string bestaande uit N herhalingen en laat het dat karakter uitvoeren. (Bijv. Een reeks van 32 spaties geeft een spatie).Welke waarden van N werken (een oneindig aantal zal werken, of geen enkele).

Opmerkingen

• Ik ‘ weet niet zeker of ik deze oplossing begrijp. Het brainfuck-programma heeft een enorm hamming-gewicht. Accepteert Unary null-bytes als programma, of zou u Unary opnieuw moeten implementeren? Als het ‘ het laatste is, is het ‘ niet echt een geldige oplossing – iedereen zou gewoon kunnen zeggen ” Ik definieer een programmeertaal waarbij elke enkele invoerbyte {resultaat} ” geeft, en win elke codegolfuitdaging op de site.
• Een nul karakter Unary zou in orde zijn. Het enige dat u nodig heeft, is een EOF om te zeggen dat u stopt met tellen. In feite is hier ‘ een pseudo-C om dat bestand te lezen: main(){ bignum Unarynum = 0; int c; while(EOF!=(c=readchar())){ Unarynum++; } return Unarynum; } Doesn ‘ het maakt helemaal niet uit wat je kiest als je Unary char (zolang het niet ‘ t EOF is).
• Nou hier ‘ is een uniforme C-compiler die prima werkt met null-tekens: ideone.com/MIvAg . Natuurlijk zou het bestand dat nodig is om dit programma te maken niet in de universe passen, maar we hebben de capaciteit om het uit te voeren.
• Als je kunt ‘ t eigenlijk voer het uit, het ‘ is niet echt een oplossing.
• Zoals Carl Sagan zei ooit: ” Als je het hamming-gewicht van een string wilt berekenen, moet je eerst 10 ^ 500 universums uitvinden. ” (miljarden en miljarden, even)

C, gewicht 322 263 256

Telt het hamerende gewicht van het hamerende gewicht?

main(D,H,A)char*A,**H;{for(A=*++H;*A;A+=!(*A/=2))D+=*A%2;printf("%d",D-2);} 

Wordt voornamelijk gebruikt voor standaard golfen technieken.
Een enkele lus berekent het gewicht (verschuift naar rechts en wordt opgeteld tot nul) en scant de tekenreeks (verplaatst de aanwijzer wanneer nul wordt bereikt).
Ervan uitgaande dat D is geïnitialiseerd op 2 (enkele parameter).

Gewichtsspecifieke optimalisatie van Hamming ons:
1. ABDH, met elk een gewicht van 2, gebruikt voor namen.
2. *++H heeft de voorkeur boven H[1].

Reacties

• Hah, ik heb je eerste zin tot nu toe totaal niet verstaan.
• U kunt de score verlagen tot 230 door het resultaat als een unair getal uit te voeren: main(D,H,A)char*A,**H;{for(A=*++H;*A;A+=!(*A/=2))if(*A%2)printf("@");}
• @schnaader , Ik heb nooit geweten dat @ een cijfer in het unaire systeem was. Ik dacht dat het alleen 0 .. 0 gebruikt. Maar als je deze kant op wilt, printf("@"+*a%2) is korter.
• @ugoren: hangt af van de conventie / definitie van unair. Bijv. en.wikipedia.org/wiki/Unary_numeral_system gebruikt wel teletekens en zegt ” Er is geen expliciet symbool dat nul vertegenwoordigt in unair zoals er is in andere traditionele bases “.
• @schnaader, OK, maar ik denk dat het ‘ s de vereiste ” uitrekken als een getal ” te ver.

Golfscript 84 72 58

{2base~}%{+}* 

(met dank aan Howard en Peter Taylor voor hun hulp)

Invoer: de invoerstring moet op de stapel staan (doorgegeven als opdrachtregel argument, of gewoon op de stapel geplaatst).

Als u het vanaf de opdrachtregel uitvoert, zorg er dan voor dat u echo -n gebruikt, anders zal de volgende nieuwe regel ook worden geteld.

Output: drukt de hamming-gewichtswaarde af op de console

Het programma kan worden getest

hier .

Reacties

• Is Golfscript hoofdlettergevoelig? Als dit niet het geval is, kunt u een paar bits opslaan door BASE te gebruiken in plaats van base. Update: zojuist aangevinkt, BASE werkt niet ‘ niet. Goede oplossing 🙂
• @Polynomial Ik heb dat geprobeerd nadat ik je TEST / test opmerking had gezien 🙂 Maar dat doet het niet ‘ t werk.
• U kunt {...}2* verwijderen door 2base~ in de eerste plaats. De score wordt verlaagd tot 72.
• @Howard bedankt voor deze geweldige tip! Ik ‘ heb het toegepast in mijn antwoord.
• Je testmechanisme is verkeerd, omdat je ‘ een belangrijke beperking van uw Web GolfScript-pagina. Je zou een ; moeten hebben voor de string die je vervangt door stdin, zodat (; niet nodig is. De observatie van Howard ‘ brengt het terug naar 65.

Perl, 80 (22 tekens)

Klaar en klaar:

perl -0777nE "say unpack"%32B*"" 

Of hier is een alternatieve versie met een gewicht van 77 (21 tekens):

perl -0777pE "$_=unpack"%32B*"" 

Ik vind die versie echter niet zo leuk, omdat de uitvoer de laatste nieuwe regel weglaat.

Om het gewicht te berekenen, ga ik ervan uit dat ik tekens op de gebruikelijke manier tel (exclusief de perl -e / -E, maar inclusief andere optietekens). Als mensen hier om de een of andere reden over klagen, dan is 90 (26 tekens) het beste wat ik zonder opties kan doen:

$/=$,,say unpack"%32B*",<> 

Voorbeeldgebruik:

$ perl -0777nE "say unpack"%32b*"" rickroll.txt 7071 

Boom.

Pyth – 15

Disclaimer: dit antwoord komt niet in aanmerking om te winnen aangezien Pyth jonger is dan deze uitdaging.

Gebruikt .B voor binaire weergave en telt het aantal "1" “s.

/.BQ\1 

Neemt invoer in een string om op te slaan op z versus Q.

Probeer het hier online .

Scala 231

 readLine().map(_.toInt.toBinaryString).flatten.map(_.toInt-48)sum  

Zelftestcode:

"""readLine().map(_.toInt.toBinaryString).flatten.map(_.toInt-48)sum""".map(_.toInt.toBinaryString).flatten.map(_.toInt-48)sum 

met zelftestmodificatie.

Reacties

• Het ‘ s gewicht 495, niet 231. U kunt ‘ geen gewicht 231 krijgen met 126 tekens – dat ‘ is een gemiddelde van minder dan 2, en alle afdrukbare tekens (behalve @ en spatie), die u ‘ t use) hebben tenminste een gewicht van 2.
• @ugoren: Maar het ‘ s slechts 65 tekens. Het programma wordt bijna twee keer afgedrukt: een keer de code om het hamming-gewicht te berekenen en een tweede keer als statische invoer om het voor het programma te berekenen. Maar het berekenende deel mist de ” readLine () ” vooraan, omdat het de letterlijke invoer accepteert. Ik heb geprobeerd het antwoord zelf te verduidelijken.

Java, gewicht 931 774 499 454

Ik denk dat dit momenteel het enige antwoord is met een gewicht van meer dan 300.

class H{public static void main(String[]A){System.out.print(new java.math.BigInteger(A[0].getBytes()).bitCount());}} 

Verwacht invoer als een opdrachtregelargument.

GNU sed -r, 467 + 1

(+1 voor gebruik van -r – of moet dat +4 zijn?)

Voert uit als een unaire waarde per bronregel; om te converteren naar een decimaal totaal, leidt u de uitvoer om naar | tr -d "\n" | wc -c. Telt alle afdrukbare ASCII-tekens (32-126), plus linefeed (10).

s@[a-z]@\U& @g s@[?{}~]@ @g s@[][/7;=>OW|^]@ @g s@[-"+.3569:<GKMNSUVYZ\\]@ @g s@[#%&)*,CEFIJL1248ORTX]@ @g s@$|[!"$(ABDH0P`]@ @g y! @!11! 

Het is moeilijk om te vermijden dat alle tekens worden vermeld, maar we kunnen waarbij wordt opgemerkt dat kleine letters een Hamming-gewicht hebben van één meer dan de overeenkomstige hoofdletters. We geven de voorkeur aan een nieuwe regel (score 2) boven puntkomma (score 5) als scheidingsteken voor een statement; we geven de voorkeur aan @ (score 1) of ! (score 2) boven / (score 5) als patroonscheidingsteken.

Opmerking – om de juiste tekensets te krijgen, heb ik deze tabel gemaakt op basis van de tabel in man ascii, gesorteerd op gewicht. Voeg gewoon de scores rechts en onder toe om het totale gewicht van elk teken te krijgen:

 2 4 3 5 6 7 --- ------ - 0: @ 0 P ` p |0 1: ! A 1 Q a q | 2: " B 2 R b r |1 4: $ D 4 T d t | 8: ( H 8 X h x | 3: # C 3 S c s | 5: % E 5 U e u | 6: & F 6 V f v |2 9: ) I 9 Y i y | A: * J : Z j z | C: , L < \ l | | 7: ´ G 7 W g w | B: + K ; [ k { |3 D: - M = ] m } | E: . N > ^ n ~ | F: / O ? _ o |4 --- ------ - 1 2 3 

Dit kan nuttig zijn voor anderen.

Julia 262 268

Gewijzigde versie gebruikt handige “count_ones” -functie voor een besparing van 6 (262)

show(mapreduce(x->count_ones(x),+,map(x->int(x),collect(ARGS[1])))) 

Oud versie zonder ingebouwde functie voor het tellen van één telling (268)

show(mapreduce(x->int(x)-48,+,mapreduce(x->bits(x),*,collect(ARGS[1])))) 

Gebruikt opdrachtregelargument voor invoer.

CJam 52 of 48

Als invoer nog niet op de stapel staat (52)

q:i2fbs:s:i:+ 

Als invoer op stapel staat (48)

:i2fbs:s:i:+ 

Bijvoorbeeld

"Hello World":i2fbs:s:i:+ 

Julia, HW 199

H=mapreduce;H(B->B=="1",+,H(P->bits(P),*,collect(A[:]))) 

Met

A="H=mapreduce;H(B->B=="1",+,H(P->bits(P),*,collect(A[:])))" 

of door de string rechtstreeks in te voegen:

julia> H=mapreduce;H(B->B=="1",+,H(P->bits(P),*,collect("H=mapreduce;H(B->B=="1",+,H(P->bits(P),*,collect(A[:])))"))) 199 

De niet-gegolfde versie (HW 411) ziet er als volgt uit:

bitstring=mapreduce(x->bits(x),*,collect(teststring[:])) mapreduce(checkbit->checkbit=="1",+,bitstring) 

En voor de lol is hier een geoptimaliseerde versie (Hamming Weight 231 ) van Bakergs kijk op het probleem:

A=mapreduce;show(A(B->int(B)-48,+,A(B->bits(B),*,collect(H[:])))) 

met

H="A=mapreduce;show(A(B->int(B)-48,+,A(B->bits(B),*,collect(H[:]))))" 

HPPPL (HP Prime Programming Language), 74

sum(hamdist(ASC(a),0)) 

De HP Prime grafische rekenmachine heeft een ingebouwde hamdist () functie.Het hamming-gewicht van elk karakter is hetzelfde als de hamming-afstand vanaf 0.

ASC (string) maakt een array van de ASCII-waarden van elk karakter in een string.

hamdist ( waarde, 0) berekent de hamming-afstand van 0 voor elke ASCII-waarde

sum () somt alle waarden op.

Berekening van het hamming-gewicht van zijn eigen broncode:

05AB1E , gewicht 17 (4 bytes )

ÇbSO 

Probeer het online of verifieer nog enkele testcases .

Uitleg:

 Ç # Convert the characters in the (implicit) input to their ASCII decimal values # i.e. "Test" → [84,101,115,116] b # Convert those values to binary # i.e. [84,101,115,116] → ["1010100","1100101","1110011","1110100"] S # Split it into a list of 0s and 1s (implicitly flattens) # i.e. ["1010100","1100101","1110011","1110100"] # → [1,0,1,0,1,0,0,1,1,0,0,1,0,1,1,1,1,0,0,1,1,1,1,1,0,1,0,0] O # Sum those (and output implicitly) # i.e. [1,0,1,0,1,0,0,1,1,0,0,1,0,1,1,1,1,0,0,1,1,1,1,1,0,1,0,0] → 16  

Perl 6 , 102

 +*.ords>>.base(2).comb(~1)  

Probeer het online!

Hoewel dit geen codegolf is, lijkt de kortste oplossing ook het kleinste hammerende gewicht te hebben …