Equilibrio alfanumerico


15

Scrivi un programma che ottiene una stringa come input e conta il numero di caratteri alfanumerici e non alfanumerici. Deve mostrare il suo risultato in questo modo:

input: http://stackexchange.com
output:20 + 4 = 24

Il problema è che il codice sorgente deve avere lo stesso numero di caratteri alfanumerici di quelli non alfanumerici. I commenti non sono ammessi, gli spazi bianchi vengono ignorati. (La lingua chiamata Whitespace potrebbe competere per i voti, ma non sarà selezionata come vincente, ovviamente)

I caratteri nel codice devono avere almeno una piccola giustificazione, non dovrebbero essere completamente superflui. Ad esempio, sono consentiti nomi di variabili più lunghi, i = (j*3)+4;invece di i = j*3+4;è consentito anche. Tuttavia, i = i + 1;;;;;;non lo è.

Oltre a questo, si applicano le regole standard del golf di codice.


Se io definisco una nuova variante pre-elaborato di Ook in cui le parole chiave sono O., O?e O!quindi qualsiasi programma di scrittura mi soddisfa la restrizione classe di caratteri ... Naturalmente è probabile perdere sul business lunghezza.
dmckee --- ex gattino moderatore

2
sarà tutto ascii?
Jordon Biondo,

@JordonBiondo: Stavo pensando a tutto ciò che vuoi dall'ANSI a 8 bit completo per unicode, ma se il tuo codice supporta solo ASCII a 7 bit, lo accetterò anche io.
vsz

3
Lo spazio bianco all'interno della stringa di output viene conteggiato in non alfanumerici? O ignorato con tutti gli altri spazi (non stringa-letterali)?
Kninnug

1
@dmckee: se hai intenzione di definire la tua lingua, basta definire una variante della lingua di tua scelta in cui i programmi non vuoti funzionano esattamente come nella lingua di base, ma il programma vuoto viene preelaborato in codice che fa esattamente ciò che il la domanda chiede.
user2357112 supporta Monica

Risposte:


8

Perl, 32 + 32 = 64

La stringa è prevista in STDIN. L'output viene scritto in STDOUT. Lo spazio bianco viene ignorato. La mia interpretazione del compito è che il programma dovrebbe essere in grado di funzionare su se stesso per ottenere il punteggio.

$/ = $,;
$_ = <>;
s x\sxxg;
$\ = length;
print s x[0-9a-z]xxgi,
      ' + ',
      s x.xxg,
      ' = '

Non rigato di commenti

$/ = $,; # The input separator becomes undefined, because the default for $, is "undef"
$_ = <>; # now $_ takes the whole file (STDIN) instead of the first line
s x\sxxg; # $_ =~ s/\s//g;
          # white space is removed from $_
$\ = length; # The number of the other characters are put into $\,
             # which is automatically printed the end of "print".
print s x[0-9a-z]xxgi, # s/[0-9a-z]//gi
                       # Remove alphanumeric characters and return their count
      ' + ',
      s x.xxg, # s/.//g
               # Remove the remaining special characters and return their count.
               # "." does not catch new lines, but we have already
               # removed white spaces including new lines.
      ' = '

Ho trovato diverse varianti con lo stesso numero di byte, ad esempio:

$/ = $x;
$_ = <>, s x\sxxg;
$\ = split $x;
print s x[\da-z]xxgi,
      " + ",
      s x.xxg,
      ' = '

Esempi

  • Esempio dalla domanda:

    echo 'http://stackexchange.com' | perl a.pl
    20 + 4 = 24
  • In esecuzione su se stesso ( a.pl):

    cat a.pl | perl a.pl
    32 + 32 = 64

    La dimensione del file è 104 byte, quindi 40 byte vengono ignorati come spazio bianco.

Perl, 29 + 29 = 58

$_=<>;s x\sxxg;$\=length;print s x[0-9a-z]xxgi,' + ',s/.//g,' = '

La stringa è prevista in STDIN ed è limitata alla prima riga. Il risultato viene stampato su STDOUT. Lo spazio bianco viene ignorato.

Ungolfed

$_ = <>;
s x\sxxg; # same as s/\s//gx; removes white space;
$\ = length($_); # sum is automatically appended at the end of print
print sx[0-9a-z]xxgi, # same as s/[0-9a-z]//gi;
                      # the number of alphanumeric characters
      ' + ',
      s/.//g, # the number of the remaining special characters
      ' = '

Esempi

Il file a.plcontiene lo script Perl.

  • Esempio dalla domanda:

    echo 'http://stackexchange.com' | perl a.pl
    20 + 4 = 24
  • In esecuzione su se stesso:

    cat a.pl | perl a.pl
    29 + 29 = 58

    La dimensione del file a.plè di 65 byte, quindi 7 byte vengono ignorati come spazio bianco.


Sembra che tu stia assumendo che l'input sia su una sola riga ... Non ho visto nulla al riguardo nelle specifiche? Inoltre, qual è la giustificazione per il flag / x nella prima sostituzione?
skibrianski,

@skibrianski: (a) La domanda non è troppo chiara sulla specifica di "stringa". Ora ho aggiunto una variante in grado di leggere interi file. (b) Inoltre non mi è chiaro come lo spazio bianco debba essere trattato dalla sceneggiatura. La mia interpretazione è che lo spazio bianco viene ignorato sia nel compito che nel punteggio. (c) Il flag / x consente lo spazio bianco nel pattern per aumentare la leggibilità. La risposta aggiornata ne fa uso.
Heiko Oberdiek,

Ri a), l'autore non dice nulla su ciò che sarà nella stringa, quindi immagino che non sia saggio fare ipotesi, il che per me significa che le nuove righe devono essere consentite. Ri b) concordato, non è chiaro. Ri c) Giusto, ma nella tua risposta lo spazio bianco non aggiunge leggibilità ai miei occhi, aggiunge solo un carattere alfanumerico ... Forse sto diventando troppo duro su questo punto, ma mi sta rivelando che usi solo / x in una delle tue regex, presumibilmente per aggiungere quell'ultimo extra alfanumerico per ottenere i conteggi da allineare =) Mi piace ancora la tua risposta. Ho preparato qualcosa di abbastanza simile.
skibrianski,

ahah ora abbiamo essenzialmente identico codice =) buon spettacolo =)
skibrianski

@skibrianski: :-) Grazie, mi dai un motivo per pubblicare una delle altre varianti con un po 'più di differenze. Tuttavia, il conteggio dei byte rimane.
Heiko Oberdiek,

6

C - 96 (48 + 48) caratteri

È in qualche modo leggibile. C'è spazio per miglioramenti, però.

i,j;main(_){while((_=getchar())>=0)isspace(_)||(isalnum(_)?i++:j++);printf("%i + %i = %i",i,j
,i+j);}

5

Bash + coreutils, 72 (36 + 36) caratteri non bianchi

a=`tr -dc [:alnum:]<<<$1|wc -c`
n=`tr -dt [:space:]<<<$1|wc -c`
echo $a + $[n-a] = $n

Produzione:

$ ./alnumbalance.sh http://stackexchange.com 
20 + 4 = 24
$ ./alnumbalance.sh "$ (cat alnumbalance.sh)"
36 + 36 = 72
$ 

Risposta precedente:

Pure Bash, 92 (46 + 46) caratteri non bianchi

nosp=${1//[[:space:]]}
noaln=${nosp//[[:alnum:]]}
echo $[${#nosp}-${#noaln}] + ${#noaln} = ${#nosp}

Produzione:

$ ./alnumbalance.sh http://stackexchange.com 
20 + 4 = 24
$ ./alnumbalance.sh "$ (cat alnumbalance.sh)"
46 + 46 = 92
$ 

Woohoo - batte persino il golfscript ! ;-)
Digital Trauma

E i personaggi di controllo? [: alnum:] non è l'inverso di [: punct:]. Prova ad esempio head -c256 / dev / urandom | tr -d [: alnum:] [: punct:]
skibrianski

@skibrianski buon punto. Ho modificato la risposta per tenerne conto.
Trauma digitale

3

PowerShell (43 + 43 = 86)

golfed

function alf($i){$a=0;$n=0;[char[]]$i|%{if($_-match"[a-zA-Z0-9]"){$a++}else{$n++}}; write-host "$a+$n=$($a+$n)"}

Un-golfed

function alf($i){
    $a=0;$n=0;  
    [char[]] $i | %{ if ($_ -match "[a-zA-Z0-9]") { $a++ } else { $n++ } };
    write-host "$a+$n=$($a + $n)"
}

Test

PS > alf "http://stackexchange.com"
20+4=24

Test con il codice stesso per superare i criteri

PS > alf "function alf($i){$a=0;$n=0;[char[]]$i|%{if($_-match`"[a-zA-Z0-9]`"){$a++}else{$n++}}; write-host `"$a+$n=$($a+$n)`"}"
43+43=86

" è stato evaso con `che non fa parte della stringa.


2

GolfScript, 74 caratteri (= 37 + 37)

{+}:PLUS;.,.@10,''*26,{65PLUS.32|}%PLUS$-,\1$-' + 'PLUS\PLUS' = 'PLUS\PLUS

Test online per il codice con il codice come input.


2

Rubino 38 + 38 = 76

Questo programma conta il newline finale nell'input.

puts"#{a=gets.scan(/[a-z0-9]/i).length}+#{b=$_.scan(/\W|_/).length}=#{a+b}"

Il conteggio dei caratteri viene eseguito dal programma stesso: $ ruby alphabalance.rb alphabalance.rb:)


2

Powershell, 70 byte (= 35 + 35)

param($s)"$(($l=$s.Length)-($n=($s|sls '\W' -a).Matches.Count))+$n=$l"

Script di prova:

$f = {
param($s)"$(($l=$s.Length)-($n=($s|sls '\W' -a).Matches.Count))+$n=$l"
}

&$f "http://stackexchange.com"
&$f $f.toString().Trim()

Produzione:

20+4=24
35+35=70

Powershell, 70 byte (= 35 + 35), alternativa

"$(($l="$args"|% Length)-($n=($args|sls '\W'-a).Matches.Count))+$n=$l"

2

Python 2 (60 + 60 = 120)

Difficile, probabilmente c'è spazio per miglioramenti. Come il fatto, la funzione stessa può essere utilizzata per valutare il proprio equilibrio alphnumerico.

def f(s):
 i=j=0
 for c in s:
  t=ord(c)
  if (t!=2**5): 
   i+=1  
  if (48<=t<=57 or 65<=t<=90 or 97<=t<=122):
   j+=1 
 print `j`,'+',`i-j`,'=',i      

Test:

>>> f("http://stackexchange.com")
20 + 4 = 24

Quale versione di Python è questa?
Gigaflop,

@Gigaflop L'ho modificato. L'istruzione print è solo Python 2, così come la sintassi backtick per repr.
mbomb007,

1

C ++, 146 (73 + 73) 178 (89 + 89) caratteri non bianchi #

Originale incluso <algorithm>senza motivo. Ops.

//create a test string
#include<string>
std::string a = "\?\?=include <cstdio>\
int x,y;\
int main()\?\?<\
    for(char c : a)\
            !isspace(c) ? (isalnum(c) ? y++ : x++) : 0;\
    printf(\"%d\?\?/t%c\?\?/t%d\?\?/t%c\?\?/t%d\?\?/n\",y,'+',x,'=',(x+y));\
\?\?>";

//Code itself starts here
??=include <cstdio>
int x,y;
int main()??<
    for(char c : a)
        !isspace(c) ? (isalnum(c) ? y++ : x++) : 0;
    printf("%d??/t%c??/t%d??/t%c??/t%d??/n",y,'+',x,'=',(x+y));
??>

Sto contando solo i caratteri nelle righe dopo //Code itself starts here. In particolare, questo significa non contare#include <string> . Sto anche contando le trigrafi come tre personaggi ciascuno, il che è forse discutibile. Si noti che nel testare il programma sul proprio codice sorgente è necessario prestare attenzione per impedire la sostituzione della trigrafo all'interno della stringa letterale.

Ci sono alcune decisioni di progettazione peculiari qui - nella maggior parte del codice di produzione non si incontreranno trigrafi e loop basati su range nella stessa funzione - ma penso che tutto rientri nei limiti di "giustificabile".


1

pitone 52 +52 = 104

Interessante sfida perché Python evita i caratteri non alfanumerici.

def f(_):
    _=_.replace(" ","");l=len(_);a=sum([c.isalnum() for c in _][:l]);print("{0} + {1} = {2}".format(a,l-a,l))

Piccola giustificazione per l'utilizzo di slice: lo accelera (forse?)


Prova a usare Python 2, poiché printnon richiede parentesi e usa il '%d + %d = %d' % (a,l-a,l)metodo. Ciò dovrebbe salvare alcuni personaggi.
mbomb007,

1

Julia, 64

f(s)=(b=endof(s);a=sum([isalnum(c) for c in s]);"$(a) + $(b-a) = $(b)";)

Tutti gli unici caratteri non alfanumerici non necessari sono l'ultimo ;e alcuni dei ()nella formattazione della stringa., È uscito quasi perfettamente bilanciato, e come una potenza di 2 senza molto giocherellare.

julia> f("http://stackexchange.com")
"20 + 4 = 24"
julia> nowhite(s)=join(split("s"," "))
julia> f(nowhite("f(s)=(b=endof(s);a=sum([isalnum(c) for c in s]);\"\$(a)+\$(b-a)=\$(b)\";)"))
"32 + 32 = 64"

1

perl, 64 caratteri non bianchi:

$/=$,;
$_=<>;
s 0\s00g;
$\=length;
print s 1[a-z0-9]11ig .
      " + " .
      s 2.22g .
      " = "

Chiarito leggermente via perl -MO = Deparse e alcuni commenti:

$/ = $,;               # input record separator = a variable defaulting to undef
$_ = <ARGV>;           # slurp stdin
s/\s//g;               # strip whitespace
$\ = length $_;        # output record separator = total length of string sans whitespace
print s/[a-z0-9]//gi . ' + ' . s/.//g . ' = '; # count alphanumerics, then everything else

ORS, $ \ viene aggiunto automaticamente in ogni chiamata da stampare, mettendo il conteggio totale alla fine.


Aveva 66 personaggi al mio primo passaggio. Grazie a Heiko Oberdiek per aver dimostrato che è possibile annullare l'impostazione di $ / con meno caratteri impostandolo su $, =)
skibrianski

1

Python 2, 50 + 50 = 100

import re
def f(i):
    w = re.sub('\s', '', i)
    s = re.subn('[\W_]', '', w)
    a = len(s[0])
    print '%d + %d = %d' % (a, s[1], a+s[1])

Eseguilo qui: http://repl.it/8CH


0

Rebol (64 + 64 = 128)

f: func [x] [
    c: :charset
    a: c [#"a" - #"z"]
    s: c [#" " #"^/" #"^-"]
    n: complement union a s
    a+: n+: 0
    parse x [
        some [
            a (++ a+) |
            n (++ n+) |
            s
        ]
    ]
    print [a+ "+" n+ "=" a+ + n+]
]

Esempio di utilizzo (nella console di Rebol):

>> f "http://stackexchange.com"
20 + 4 = 24

NB. Il programma ignora gli spazi, le schede e le nuove righe dai conteggi.


0

J - 46 + 46 = 92

Conta gli spazi bianchi, quindi non puoi eseguire l'autotest senza una modifica. Accetta input su stdin. Ha una brutta bocca, dovrebbe andare a lavarlo con il sapone.

;":&.>(+/;' + ';(#-+/);' = ';#)(e.~1!:1@1:)(,toupper)'golfscriptSUCKSabdehjkmnquvwxyz',,":"0 i.10

Uso:

   ;":&.>(+/;' + ';(#-+/);' = ';#)(e.~1!:1@1:)(,toupper)'golfscriptSUCKSabdehjkmnquvwxyz',,":"0 i.10
http://stackexchange.com
20 + 4 = 24

   NB. modification for self-test:    vvvvvv - remove spaces, the only whitespace
   ;":&.>(+/;' + ';(#-+/);' = ';#)(e.~' '-.~1!:1@1:)(,toupper)'golfscriptSUCKSabdehjkmnquvwxyz',,":"0 i.10
;":&.>(+/;' + ';(#-+/);' = ';#)(e.~1!:1@1:)(,toupper)'golfscriptSUCKSabdehjkmnquvwxyz',,":"0 i.10
46 + 46 = 92

0

Javascript - 76 (38 + 38)

_ = prompt()
o = _.match(/[a-z0-9]/gi).length
$ = _.length - o
alert(o + " + " + $ + " = " + (o + $))

Esempio di input: http://stackexchange.com
output:20 + 4 = 24

In esecuzione su se stesso:

var a  = '_ = prompt()o = _.match(/[a-z0-9]/gi).length$ = _.length - oalert(o + " + " + $ + " = " + (o + $))'

var letters = a.match(/[a-z0-9]/g).length; 
var nons = a.match(/[^a-z0-9 ]/g).length; // excludes whitespace from count

console.log(nons + " = " + letters); // 38 = 38 :)

PS Per coloro che si occupano (o + $)di mantenere l'equilibrio alfanumerico, non è così. Perché dopo aver visto o + " + "JS avrebbe deciso +di essere tutti concatenatori di stringhe piuttosto che numeri aggiunti. Pertanto le parentesi sono necessarie o 20 + 4diventerebbero 204piuttosto che24 : D

Buona programmazione!


0

Clojure: (31 + 31 = 62) caratteri non bianchi

(def ff #(let [c count y (c %) x (c (re-seq #"\w" %))] (str x " + " (- y x) " = " y)))

Produzione:

alphabalance.core=> (ff "http://stackexchange.com")
"20 + 4 = 24"

0

CJam, 27 + 27 = 54

CJam è un paio di mesi più recente di questa sfida, quindi questa risposta non è ammissibile per il segno di spunta verde. Comunque è stato un esercizio divertente!

ea0=eu{A,s'[,65>+#)g}%_:+1@f-:+ea0=,]"DODDaD"36f-3/]zo

Prende la stringa di input come argomento della riga di comando, quindi non funzionerà nell'interprete online, ma è possibile testarla con l' interprete Java .

Spiegazione

"Distinguish alphanumeric characters:";
ea0=eu{A,s'[,65>+#)g}%
ea0=                   "Get the first command-line argument.";
    eu                 "Convert it to upper case.";
      {             }% "Map this block onto each character.";
       A,s             "Get the string '0123456789'.";
          '[,          "Get a string with all characters from the null byte to Z.";
             65>       "Remove the first 65 characters, to leave A to Z.";
                +      "Add to digit.";
                 #     "Find character in that string. Returns -1 if not alphanumeric.":
                  )g   "Increment and get signum. Yields 1 for alphanumeric characters,
                        0 otherwise.";

"Now we've got an array of 0s and 1s. Let's do the counting:";
_:+1@f-:+ea0=,]
_               "Duplicate array.";
 :+             "Get the sum. This is the number of alphanumeric characters.";
   1@           "Push a 1 and pull up the other copy of the array.";
     f-         "Subtract each element from 1, this swaps 0s and 1s.";
       :+       "Get the sum. This is the number of symbol characters.";
         ea0=   "Get the first command-line argument again.";
             ,  "Get its length. This is the total number of characters.";
              ] "Collect everything in an array.";

"And now the formatting:";
"DODDaD"36f-3/]zo
"DODDaD"          "Push this string.";
        36f-      "Subtract 36 from each character. This yields ' +  = '.";
            3/    "Split into two halves of 3 characters each.";
              ]   "Wrap this and the previous array in another array.";
               z  "Zip. Transposes the array to interleave strings with numbers.";
                o "Output the resulting array without delimiters.";
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.