Bei dieser Herausforderung debattieren Sie und Ihre Freunde darüber, welche Groß- oder Kleinschreibung besser ist. Um dies herauszufinden, schreiben Sie ein Programm, das dies für Sie erledigt.

Da esolangs Ihre Freunde und ausführlicher Code Sie erschreckt, muss Ihr Code so kurz wie möglich sein.

Beispiele

PrOgRaMiNgPuZzLeS & CoDe GoLf
0.52 uppercase

DowNGoAT RiGHtGoAt LeFTGoat UpGoAT
0.58 uppercase

Foo BaR Baz
0.56 lowercase

Spezifikationen

Die Eingabe besteht nur aus ASCII-Zeichen. Alle nicht alphabetischen Zeichen sollten ignoriert werden. Es wird mindestens 1 Charakter von jedem Fall geben

Die Ausgabe sollte die Menge der Groß- / Kleinschreibung sein, die am häufigsten über der Gesamtmenge der alphabetischen Zeichen angezeigt wird. Es sollte eine Dezimalstelle mit einer Genauigkeit von mindestens 2 Dezimalstellen sein. Wenn häufiger Großbuchstaben angezeigt werden, sollte die Ausgabe mit uppercaseoder enden lowercase.

Es wird niemals die gleiche Anzahl von Groß- und Kleinbuchstaben geben.

Pyth - 40 Bytes

Dies ist das erste Mal, dass ich eine vektorisierte String-Formatierung verwende, was ziemlich cool ist.

Kml-zrzd2eS%Vm+cdsK" %sercase"Kc"upp low

Test Suite .

JavaScript (ES6) 87 Byte

Edit 1 Byte gespeichert thx ETHProductions
Edit 1 Byte gespeichert thx l4me

Eine anonyme Funktion. Lange, aber ich fand keinen Weg mehr zum Golfen

s=>(l=t=0,s.replace(/[a-z]/ig,c=>l+=++t&&c>'Z'),l/=t,l<.5?1-l+' upp':l+' low')+'ercase'

Weniger golfen

s=>( // arrow function returning the value of an expression
  // here I use comma for clarity, 
  // in the golfed version it's all merged in a single expression
  t = 0, // counter for letters
  l = 0, // counter for lowercase letters 
  s.replace(
    /[a-z]/ig, // find all alphabetic chars, upper or lowercase
    c => // execute for each found char (in c)
        l += ++t && c>'Z', // increment t, increment l if c is lowercase
  ),
  l /= t, // l is the ratio now
  ( l < .5 // if ratio < 1/2
    ? (1-l) +' upp' // uppercase count / total (+" upp")
    : l +' low'     // lowrcase count / total (+" low")
  ) + 'ercase' // common suffix
)

CJam, 47 45 Bytes

q__eu-\_el-]:,_:+df/" low upp"4/.+:e>"ercase"

Probieren Sie es online aus.

Nicht zu lange golfen ...

Erläuterung

q               e# Read input.
__eu-           e# Get only the lowercase characters.
\_el-           e# Get only the uppercase characters.
]:,             e# Get the lengths of the two strings.
_:+             e# Sum of the lengths.
df/             e# Lengths divided by the sum of the lengths.
" low upp"4/.+  e# Append the first number with " low" and the second " upp"
:e>             e# Find the maximum of the two.
"ercase"        e# Output other things.

Japt , 58 Bytes

A=Uf"[a-z]" l /Uf"[A-Za-z]" l)>½?A+" low":1-A+" upp" +`ÖÐ

(Hinweis: SE hat zuvor ein Sonderzeichen entfernt. ÖKlicken Sie daher auf den Link, um den richtigen Code zu erhalten.)

R , 133 123 118 108 106 105 104 Bytes

Dank @ovs 10 Bytes weniger, dank @Giuseppe 8 und dank @ngm nochmals 10 Bytes weniger. An diesem Punkt ist es wirklich eine gemeinsame Anstrengung, bei der ich die Bytes zur Verfügung stelle und andere sie entfernen;)

function(x)cat(max(U<-mean(utf8ToInt(gsub('[^a-zA-Z]',"",x))<91),1-U),c("lowercase","uppercase")[1+2*U])

Probieren Sie es online!

MATL , 49 50 Bytes

Verwendet die aktuelle Version (4.1.1) der Sprache, die älter als die Herausforderung ist.

jt3Y2m)tk=Ymt.5<?1w-YU' upp'h}YU' low'h]'ercase'h

Beispiele

>> matl
 > jt3Y2m)tk=Ymt.5<?1w-YU' upp'h}YU' low'h]'ercase'h
 > 
> PrOgRaMiNgPuZzLeS & CoDe GoLf
0.52 uppercase

>> matl
 > jt3Y2m)tk=Ymt.5<?1w-YU' upp'h}YU' low'h]'ercase'h
 > 
> Foo BaR Baz
0.55556 lowercase

Erläuterung

j                   % input string
t3Y2m)              % duplicate. Keep only letters
tk=Ym               % duplicate. Proportion of lowercase letters
t.5<?               % if less than .5
    1w-             % compute complement of proportion
    YU' upp'h       % convert to string and append ' upp'
}                   % else
    YU' low'h       % convert to string and append ' low' 
]                   % end
'ercase'            % append 'ercase'

Julia, 76 74 Bytes

s->(x=sum(isupper,s)/sum(isalpha,s);(x>0.5?"$x upp":"$(1-x) low")"ercase")

Dies ist eine Lambda-Funktion, die eine Zeichenfolge akzeptiert und eine Zeichenfolge zurückgibt. Um es aufzurufen, weisen Sie es einer Variablen zu.

Ungolfed:

function f(s::AbstractString)
    # Compute the proportion of uppercase letters
    x = sum(isupper, s) / sum(isalpha, s)

    # Return a string construct as x or 1-x and the appropriate case
    (x > 0.5 ? "$x upp" : "$(1-x) low") * "ercase"
end

2 Bytes gespart dank edc65!

Perl 6 ,  91 70 69 63   61 Bytes

{($/=($/=@=.comb(/\w/)).grep(*~&' 'ne' ')/$/);"{$/>.5??$/!!1-$/} {<low upp>[$/>.5]}ercase"} # 91

{$/=m:g{<upper>}/m:g{\w};"{$/>.5??$/!!1-$/} {<low upp>[$/>.5]}ercase"} # 70

{"{($/=m:g{<upper>}/m:g{\w})>.5??$/!!1-$/} {<low upp>[$/>.5]}ercase"} # 69

{"{($/=m:g{<upper>}/m:g{\w})>.5??"$/ upp"!!1-$/~' low'}ercase"} # 63

{"{($/=m:g{<:Lu>}/m:g{\w})>.5??"$/ upp"!!1-$/~' low'}ercase"} # 61

Verwendung:

# give it a lexical name
my &code = {...}

.say for (
  'PrOgRaMiNgPuZzLeS & CoDe GoLf',
  'DowNGoAT RiGHtGoAt LeFTGoat UpGoAT',
  'Foo BaR Baz',
)».&code;

0.52 uppercase
0.580645 uppercase
0.555556 lowercase

C #, 135 Bytes

Benötigt:

using System.Linq;

Tatsächliche Funktion:

string U(string s){var c=s.Count(char.IsUpper)*1F/s.Count(char.IsLetter);return(c>0.5?c+" upp":1-c+" low")+"ercase";}

Mit Erklärung:

string U(string s)
{
    var c = s.Count(char.IsUpper) // count uppercase letters
               * 1F               // make it a float (less bytes than (float) cast)
               / s.Count(char.IsLetter); // divide it by the total count of letters
    return (c > 0.5 
        ? c + " upp"  // if ratio is greater than 0.5, the result is "<ratio> upp"
        : 1 - c + " low") // otherwise, "<ratio> low"
        + "ercase"; // add "ercase" to the output string
}

Python 2, 114 110 Bytes

i=input()
n=1.*sum('@'<c<'['for c in i)/sum(c.isalpha()for c in i)
print max(n,1-n),'ulpopw'[n<.5::2]+'ercase'

Mathematica, 139 105 Bytes

a=ToString;If[(b=1.#~(c=StringCount)~Alphabet[]/c[#,_?LetterQ])<.5,a[1-b]<>" upp",a@b<>" low"]<>"ercase"&

Ausführlicher Code ist beängstigend , aber ich muss damit leben ...

PHP, 140 129 Zeichen

Meine erste Golfrunde - nicht schlecht für eine "Standard" -Sprache, oder? :-)

Original:

function f($s){$a=count_chars($s);for($i=65;$i<91;$i++){$u+=$a[$i];$l+=$a[$i+32];}return max($u,$l)/($u+$l).($u<$l?' low':' upp').'ercase';}

Verkürzt auf 129 Zeichen dank @manatwork:

function f($s){$a=count_chars($s);for(;$i<26;$u+=$a[$i+++65])$l+=$a[$i+97];return max($u,$l)/($u+$l).' '.($u<$l?low:upp).ercase;}

Mit Kommentaren:

function uclcratio($s)
{
  // Get info about string, see http://php.net/manual/de/function.count-chars.php
  $array = count_chars($s);

  // Loop through A to Z
  for ($i = 65; $i < 91; $i++) // <91 rather than <=90 to save a byte
  {
    // Add up occurrences of uppercase letters (ASCII 65-90)
    $uppercount += $array[$i];
    // Same with lowercase (ASCII 97-122)
    $lowercount += $array[$i+32];
  }
  // Compose output
  // Ratio is max over sum
  return max($uppercount, $lowercount) / ($uppercount + $lowercount)
  // in favour of which, equality not possible per challenge definition
         . ($uppercount < $lowercount ? ' low' : ' upp') . 'ercase';
}

Rubin, 81 + 1 = 82

Mit Flagge -p,

$_=["#{r=$_.count(a='a-z').fdiv$_.count(a+'A-Z')} low","#{1-r} upp"].max+'ercase'

Glücklicherweise ist die lexikografische Sortierung für Zahlen zwischen 0 und 1 die gleiche wie die numerische Sortierung.

Common Lisp, 132 Bytes

(setq s(read-line)f(/(count-if'upper-case-p s)(count-if'alpha-char-p s)))(format t"~f ~aercase"(max f(- 1 f))(if(> f .5)"upp""low"))

Probieren Sie es online!

Gema, 125 Zeichen

\A=@set{l;0}@set{u;0}
<J1>=@incr{l}
<K1>=@incr{u}
?=
\Z=0.@div{@cmpn{$l;$u;$u;;$l}00;@add{$l;$u}} @cmpn{$l;$u;upp;;low}ercase

Probelauf:

bash-4.3$ for input in 'PrOgRaMiNgPuZzLeS & CoDe GoLf' 'DowNGoAT RiGHtGoAt LeFTGoat UpGoAT' 'Foo BaR Baz'; do
>     gema '\A=@set{l;0}@set{u;0};<J1>=@incr{l};<K1>=@incr{u};?=;\Z=0.@div{@cmpn{$l;$u;$u;;$l}00;@add{$l;$u}} @cmpn{$l;$u;upp;;low}ercase' <<< "$input"
>     echo " <- $input"
> done
0.52 uppercase <- PrOgRaMiNgPuZzLeS & CoDe GoLf
0.58 uppercase <- DowNGoAT RiGHtGoAt LeFTGoat UpGoAT
0.55 lowercase <- Foo BaR Baz

Im Ernst, 58 Bytes

" upp"" low"k"ercase"@+╗,;;ú;û+∩@-@-;l@ú@-l/;1-k;i<@╜@ZEεj

Hex Dump:

22207570702222206c6f77226b2265726361736522402bbb2c3b3ba33b
962bef402d402d3b6c40a3402d6c2f3b312d6b3b693c40bd405a45ee6a

Es funktioniert nur mit dem herunterladbaren Interpreter ... der Online-Interpreter ist immer noch defekt.

Erläuterung:

" upp"" low"k"ercase"@+╗                                    Put [" lowercase"," uppercase"]
                                                            in reg0
                        ,;;ú;û+∩@-@-                        Read input, remove non-alpha
                                    ;l@                     Put its length below it
                                       ú@-                  Delete lowercase
                                          l                 Get its length
                                           /                Get the ratio of upper/total
                                            ;1-k            Make list [upp-ratio,low-ratio]
                                                ;i<         Push 1 if low-ratio is higher
                                                   @        Move list to top
                                                    ╜@Z     Zip it with list from reg0
                                                       E    Pick the one with higher ratio
                                                        εj  Convert list to string.

Pyth, 45 Bytes

AeSK.e,s/LzbkrBG1s[cGshMKd?H"upp""low""ercase

Probieren Sie es online aus. Testsuite.

Erläuterung

             rBG1               pair of alphabet, uppercase alphabet
    .e                          map k, b over enumerate of that:
      ,                           pair of
           b                          lowercase or uppercase alphabet
        /Lz                           counts of these characters in input
       s                              sum of that
                                    and
            k                         0 for lowercase, 1 for uppercase
   K                            save result in K
 eS                             sort the pairs & take the larger one
A                               save the number of letters in and the 0 or 1 in H

s[                              print the following on one line:
  cG                              larger number of letters divided by
    shMK                            sum of first items of all items of K
                                    (= the total number of letters)
        d                         space
         ?H"upp""low"             "upp" if H is 1 (for uppercase), otherwise "low"
                     "ercase      "ercase"

Coffeescript, 104 Zeichen

 (a)->(r=1.0*a.replace(/\W|[A-Z]/g,'').length/a.length)&&"#{(r>.5&&(r+' low')||(1-r+' upp'))+'ercase'}"

coffeescript versuchte anfangs, den beabsichtigten Rückgabewert als Argument an den Wert "r" zu übergeben. Dies schlug fehl und war sehr ärgerlich, da r eine Zahl und keine Funktion war. Ich habe es umgangen, indem ich ein &&zwischen die Anweisungen gesetzt habe, um sie zu trennen.

Pyth, 54 53

Ein Byte gespart dank @Maltysen

K0VzI}NG=hZ)I}NrG1=hK;ceS,ZK+ZK+?>ZK"low""upp""ercase

Probieren Sie es online aus

K0                  " Set K to 0
                    " (Implicit: Set Z to 0)

Vz                  " For all characters (V) in input (z):
  I}NG              " If the character (N) is in (}) the lowercase alphabet (G):
    =hZ             " Increment (=h) Z
  )                 " End statement
  I}NrG1            " If the character is in the uppercase alphabet (rG1):
    =hK             " Increment K
;                   " End all unclosed statements/loops

c                   " (Implicit print) The division of
  e                 " the last element of
    S,ZK           " the sorted (S) list of Z and K (this returns the max value)
+ZK                 " by the sum of Z and K

+                   " (Implicit print) The concatenation of
  ?>ZK"low""upp"    " "low" if Z > K, else "upp"
  "ercase"          " and the string "ercase".

Ruby, 97 Zeichen

->s{'%f %sercase'%[(l,u=[/[a-z]/,/[A-Z]/].map{|r|s.scan(r).size}).max.fdiv(l+u),l>u ?:low: :upp]}

Probelauf:

2.1.5 :001 > ['PrOgRaMiNgPuZzLeS & CoDe GoLf', 'DowNGoAT RiGHtGoAt LeFTGoat UpGoAT', 'Foo BaR Baz'].map{|s|->s{'%f %sercase'%[(l,u=[/[a-z]/,/[A-Z]/].map{|r|s.scan(r).size}).max.fdiv(l+u),l>u ?:low: :upp]}[s]}
 => ["0.520000 uppercase", "0.580645 uppercase", "0.555556 lowercase"] 

05AB1E , 28 Bytes

ʒ.u}gság/Dò©_αð„Œ„›…#'ƒß«®èJ

Probieren Sie es online!

ʒ.u}g                        # filter all but uppercase letters, get length.
     ság/                    # Differential between uppercase and input length.
         Dò©                 # Round up store result in register w/o pop.
            _α               # Negated, absolute difference.
              ð              # Push space.
               „Œ„›…         # Push "upper lower"
                    #        # Split on space.
                     'ƒß«    # Concat "case" resulting in [uppercase,lowercase]
                         ®èJ # Bring it all together.

Java 8, 136 130 Bytes

s->{float l=s.replaceAll("[^a-z]","").length();l/=l+s.replaceAll("[^A-Z]","").length();return(l<.5?1-l+" upp":l+" low")+"ercase";}

-6 Bytes, die einen Port von erstellen C # .NET-Antwort @ProgramFOX.

Probieren Sie es online aus.

Erläuterung:

s->{                  // Method with String as both parameter and return-type
  float l=s.replaceAll("[^a-z]","").length();
                      //  Amount of lowercase
  l/=l+s.replaceAll("[^A-Z]","").length();
                      //  Lowercase compared to total amount of letters
  return(l<.5?        //  If this is below 0.5:
          1-l+" upp"  //   Return `1-l`, and append " upp"
         :            //  Else:
          l+" low")   //   Return `l`, and append " low"
        +"ercase";}   //  And append "ercase"

REXX, 144 Bytes

a=arg(1)
l=n(upper(a))
u=n(lower(a))
c.0='upp';c.1='low'
d=u<l
say 1/((u+l)/max(u,l)) c.d'ercase'
n:return length(space(translate(a,,arg(1)),0))

Perl 5 -p , 72 Bytes

$_=(($u=y/A-Z//)>($l=y/a-z//)?$u:$l)/($u+$l).$".($u>$l?upp:low).'ercase'

Probieren Sie es online!

Kotlin , 138 Bytes

Code

let{var u=0.0
var l=0.0
forEach{when{it.isUpperCase()->u++
it.isLowerCase()->l++}}
"${maxOf(u,l)/(u+l)} ${if(u>l)"upp" else "low"}ercase"}

Verwendung

fun String.y():String =let{var u=0.0
var l=0.0
forEach{when{it.isUpperCase()->u++
it.isLowerCase()->l++}}
"${maxOf(u,l)/(u+l)} ${if(u>l)"upp" else "low"}ercase"}

fun main(args: Array<String>) {
    println("PrOgRaMiNgPuZzLeS & CoDe GoLf".y())
    println("DowNGoAT RiGHtGoAt LeFTGoat UpGoAT".y())
    println("Foo BaR Baz".y())
}

Pyth, 40 bis 39 Bytes

Jml@dQrBG1+jdeS.T,cRsJJc2."kw񽙽""ercase

Probieren Sie es hier aus

Erläuterung

Jml@dQrBG1+jdeS.T,cRsJJc2."kw񽙽""ercase
 m    rBG1                                For the lower and uppercase alphabet...
  l@dQ                                    ... count the occurrences in the input.
J                 cRsJJ                   Convert to frequencies.
               .T,     c2."kw񽙽"          Pair each with the appropriate case.
             eS                           Get the more frequent.
          +jd                    "ercase  Stick it all together.

PowerShell Core , 134 128 Byte

Filter F{$p=($_-creplace"[^A-Z]",'').Length/($_-replace"[^a-z]",'').Length;$l=1-$p;(.({"$p upp"},{"$l low"})[$p-lt$l])+"ercase"}

Probieren Sie es online!

Vielen Dank, Veskah , dass Sie sechs Bytes gespart haben , indem Sie die Funktion in einen Filter konvertiert haben!

Tcl , 166 Bytes

proc C s {lmap c [split $s ""] {if [string is u $c] {incr u}
if [string is lo $c] {incr l}}
puts [expr $u>$l?"[expr $u./($u+$l)] upp":"[expr $l./($u+$l)] low"]ercase}

Probieren Sie es online!

APL (NARS), 58 Zeichen, 116 Bytes

{m←+/⍵∊⎕A⋄n←+/⍵∊⎕a⋄∊((n⌈m)÷m+n),{m>n:'upp'⋄'low'}'ercase'}

Prüfung:

  h←{m←+/⍵∊⎕A⋄n←+/⍵∊⎕a⋄∊((n⌈m)÷m+n),{m>n:'upp'⋄'low'}'ercase'}
  h "PrOgRaMiNgPuZzLeS & CoDe GoLf"
0.52 uppercase
  h "DowNGoAT RiGHtGoAt LeFTGoat UpGoAT"
0.5806451613 uppercase
  h "Foo BaR Baz"
0.5555555556 lowercase

C, 120 Bytes

f(char*a){int m=0,k=0,c;for(;isalpha(c=*a++)?c&32?++k:++m:c;);printf("%f %sercase",(m>k?m:k)/(m+k+.0),m>k?"upp":"low");}

Test und Ergebnis:

main()
{char *p="PrOgRaMiNgPuZzLeS & CoDe GoLf", *q="DowNGoAT RiGHtGoAt LeFTGoat UpGoAT", *m="Foo BaR Baz";
 f(p);printf("\n");f(q);printf("\n");f(m);printf("\n");
}

Ergebnisse

0.520000 uppercase
0.580645 uppercase
0.555556 lowercase

Es nehme Ascii-Zeichensatz.