Stosunek wielkich liter do małych liter

28

W tym wyzwaniu ty i twoi znajomi zastanawiacie się, która sprawa jest lepsza, wielka czy mała? Aby się o tym dowiedzieć, piszesz program, który zrobi to za Ciebie.

Ponieważ esolangi straszą twoich przyjaciół, a pełny kod przeraża cię, twój kod musi być tak krótki, jak to możliwe.


Przykłady

PrOgRaMiNgPuZzLeS & CoDe GoLf
0.52 uppercase

DowNGoAT RiGHtGoAt LeFTGoat UpGoAT
0.58 uppercase

Foo BaR Baz
0.56 lowercase

Dane techniczne

Dane wejściowe będą składały się wyłącznie ze znaków ASCII. Wszystkie znaki niealfabetyczne powinny być ignorowane. W każdym przypadku będzie co najmniej 1 znak

Wynikiem powinna być wielkość liter, która pojawia się najczęściej w stosunku do całkowitej liczby znaków alfabetycznych. Powinna być dziesiętna z dokładnością do co najmniej 2 miejsc po przecinku. Jeśli duże litery pojawiają się częściej, wynik powinien kończyć się uppercase, lub lowercase.

Nigdy nie będzie takiej samej liczby wielkich i małych liter.

Downgoat
źródło
7
Esolangi nie straszą moich przyjaciół. Czy to oznacza, że ​​mój kod może być bardzo gadatliwy?
Alex A.,
@AlexA. pełny kod przeraża cię, więc twój kod będzie musiał zostać golfem.
Downgoat,
16
No tak, zapomniałem o moich powtarzających się koszmarach z Jawy.
Alex A.,
4
Czy wprowadzony zostanie tylko jeden przypadek?
manatwork,
1
Czy „z dokładnością do co najmniej 2 miejsc po przecinku” wymaga wydrukowania co najmniej dwóch miejsc po przecinku, czy też można pominąć drugi przecinek dziesiętny?
hvd,

Odpowiedzi:

2

Pyth - 40 bajtów

Po raz pierwszy użyłem formatowania ciągów wektoryzowanych, co jest całkiem fajne.

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

Pakiet testowy .

Maltysen
źródło
7

JavaScript (ES6) 87 bajtów

Edytuj 1 bajt zapisany dzięki ETHProductions
Edytuj 1 dodatkowy bajt zapisany dzięki l4me

Anonimowa funkcja. Długo, ale nie znalazłem już sposobu na grę w golfa

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

Mniej golfa

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
)
edc65
źródło
Wierzę, że możesz zaoszczędzić jeden bajt, używając &&` ${t-l>l?1-l/t+'upp':l/t+'low'}ercase` .
ETHproductions
Ponadto, c=>l+=++t&&c>'Z'czy działałoby, tak myślę ...?
ETHproductions
@ETHproductions Twoja pierwsza wskazówka nie wydaje się przydatna, druga jest sprytna, thx
edc65
1
Czy możemy zobaczyć wersję bez golfa z wyjaśnieniem?
Cyoce,
Dodano wyjaśnienie @Cyoce - w rzeczywistości jest proste
edc65
4

CJam, 47 45 bajtów

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

Wypróbuj online.

Nie grałem zbyt długo w golfa ...

Wyjaśnienie

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.
jimmy23013
źródło
4

Japt , 58 bajtów

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

(Uwaga: SE wcześniej usunęła specjalny znak, Öwięc kliknij link, aby uzyskać odpowiedni kod)

Nicość
źródło
Dobra robota! Twoje pierwsze wyrażenie regularne (w tym znaki dolara) można zastąpić "[a-z]", a drugie - "A-Za-z". 0.5jest równy ½. Możesz także usunąć końcowy znak cudzysłowu.
ETHproductions
Przy wspomnianych zmianach i kompresji ciągów otrzymuję 58: A=Uf"[a-z]" l /Uf"[A-Za-z]" l)>½?A+" low":1-A+" upp" +`\x80ÖÐMożesz uzyskać surową wersję ostatnich trzech bajtów za pomocą Oc"ercase.
ETHproductions
@Eth najwyraźniej \x80nic nie zrobił i ÖÐwyprodukował „skrzynkę” ... Może jakieś znaki niewidoczne, które zostały obcięte? Btw, pod warunkiem mój własny mod, dzięki za wskazówki
nicael
@ETH Ok, udało się użyć tego invisi-char :)
nicael
Niestety, odwrotne ukośniki muszą zostać podwojone wewnątrz ciągów, aby parser wyrażeń regularnych działał. W takich przypadkach "\w"po prostu dopasowuje wszystkie ws i "\\w"pasuje do wszystkich A-Za-z0-9_. Więc myślę, że musisz to zatrzymać "[a-z]".
ETHproductions
4

R , 133 123 118 108 106 105 104 bajtów

Grałem w golfa o 10 bajtów dzięki @ ovs, 8 dzięki @Giuseppe i 10 ponownie dzięki @ngm. W tym momencie jest to naprawdę wspólny wysiłek, w którym dostarczam bajty, a inni je usuwają;)

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

Wypróbuj online!

JayCe
źródło
wygolił jeszcze 1 bajt.
JayCe,
3

MATL , 49 50 bajtów

Używa bieżącej wersji (4.1.1) języka, która jest wcześniejsza niż wyzwanie.

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

Przykłady

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

Wyjaśnienie

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'
Luis Mendo
źródło
3

Julia, 76 74 bajtów

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

Jest to funkcja lambda, która przyjmuje ciąg i zwraca ciąg. Aby go wywołać, przypisz go do zmiennej.

Nie golfowany:

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

Zaoszczędzono 2 bajty dzięki edc65!

Alex A.
źródło
1
Możesz z pewnością zapisać 2 bajty, używając ercasezamiastcase
edc65
@ edc65 Świetny pomysł, dzięki!
Alex A.,
3

Perl 6 ,  91 70 69 63   61 bajtów

{($/=($/=@=.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

Stosowanie:

# 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
Brad Gilbert b2gills
źródło
2
Przekreślone bloki kodu? To coś nowego ...
Bojidar Marinov,
1
Strać 3 znaki, zamieniając trójskładnik na maksimum („0,55 w górę”, „0,45 niski”): Spróbuj
Phil H
3

C #, 135 bajtów

Wymaga:

using System.Linq;

Rzeczywista funkcja:

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

Z wyjaśnieniem:

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
}
ProgramFOX
źródło
3

Python 2, 114 110 bajtów

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'
TFeld
źródło
1
Możesz zapisać 2 bajty, zastępując ['upp','low'][n<.5]je 'ulpopw'[n<.5::2], i 3 kolejne, zastępując [n,1-n][n<.5]je max(n,1-n).
PurkkaKoodari,
2

Mathematica, 139 105 bajtów

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

Pełny kod jest przerażający , ale muszę z tym żyć ...

LegionMammal978
źródło
2

PHP, 140 129 znaków

Moja pierwsza runda golfa - nieźle jak na „standardowy” język, co? :-)

Oryginalny:

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

Skrócony do 129 znaków dzięki @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;}

Z komentarzami:

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';
}
Christallkeks
źródło
Biorąc pod uwagę $u+=…, przypuszczam, że masz już error_reportingdomyślnie, więc wyciszaj ostrzeżenia. Następnie wyjąć kilka cytatów: ' '.($u<$l?low:upp).ercase.
manatwork
Jeśli miałbyś tylko jedno zdanie do powtórzenia for, możesz usunąć nawiasy klamrowe wokół niego. for($i=65;$i<91;$u+=$a[$i++])$l+=$a[$i+32];
manatwork
Za cenę kolejnego ostrzeżenia można oszczędzić forinicjalizację zmiennej kontrolnej, zapętlając 0..26 zamiast 65..91:for(;$i<26;$u+=$a[$i+++65])$l+=$a[$i+97];
manatwork
Wow, dziękuję @manatwork, nie wiedziałem, jak tolerancyjny jest PHP! : D Drugi jest bardzo inteligentny. Wdrożyłem twoje pomysły, zwiększając liczbę do 140-4-5-2 = 129 :-)
Christallkeks
2

Rubin, 81 + 1 = 82

Z flagą -p,

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

Na szczęście dla liczb od 0 do 1 sortowanie leksykograficzne jest takie samo jak sortowanie numeryczne.

histocrat
źródło
2

Common Lisp, 132 bajty

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

Wypróbuj online!

Renzo
źródło
W teście 0,52 to wielkie litery, a nie małe ...
RosLuP,
1
@RosLuP, poprawione, wielkie dzięki!
Renzo,
1

Gema, 125 znaków

\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

Przykładowy przebieg:

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
człowiek w pracy
źródło
-1, ponieważ esolangi straszą twoich przyjaciół. (JK, głosowano)
komendant ev3,
1

Poważnie, 58 bajtów

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

Hex Dump:

22207570702222206c6f77226b2265726361736522402bbb2c3b3ba33b
962bef402d402d3b6c40a3402d6c2f3b312d6b3b693c40bd405a45ee6a

Działa tylko w przypadku tłumacza do pobrania ... on-line jest nadal uszkodzony.

Wyjaśnienie:

" 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.
kwintopia
źródło
1

Pyth, 45 bajtów

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

Wypróbuj online. Zestaw testowy.

Wyjaśnienie

             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"
PurkkaKoodari
źródło
1

CoffeeScript, 104 znaki

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

coffeescript początkowo próbował przekazać zamierzoną wartość zwracaną jako argument wartości „r”, co się nie powiodło i było bardzo denerwujące, ponieważ r było liczbą, a nie funkcją. Obejrzałem to, umieszczając &&między instrukcjami, aby je rozdzielić.

John Dikeman
źródło
1

Pyth, 54 53

Jeden bajt zapisany dzięki @Maltysen

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

Wypróbuj online

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".
RK.
źródło
,<any><any>to polecenie dwóch arii, które jest tym samym, [<any><any>)co może uratować ci bajt
Maltysen
1

Ruby, 97 znaków

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

Przykładowy przebieg:

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"] 
człowiek w pracy
źródło
1

05AB1E , 28 bajtów

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

Wypróbuj 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.
Urna Magicznej Ośmiornicy
źródło
1

Java 8, 136 130 bajtów

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 bajtów, tworząc port odpowiedzi @ProgramFOX C # .NET .

Wypróbuj online.

Wyjaśnienie:

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"
Kevin Cruijssen
źródło
1

REXX, 144 bajty

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))
idrougge
źródło
1

Kotlin , 138 bajtów

Kod

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

Stosowanie

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())
}
jrtapsell
źródło
1

Pyth, 40 39 bajtów

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

Wypróbuj tutaj

Wyjaśnienie

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.

źródło
1

PowerShell Core , 134 128 bajtów

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

Wypróbuj online!

Dzięki, Veskah , za zapisanie sześciu bajtów poprzez zamianę funkcji na filtr!

Jeff Freeman
źródło
1
Możesz zapisać dwa wolne bajty, czyniąc z niego filtr zamiast funkcji, tj. Filtr F (kod)
Veskah
Nigdy nie wiedziałem, że to była rzecz! Dzięki, Veskah!
Jeff Freeman
1

Tcl , 166 bajtów

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}

Wypróbuj online!

sergiol
źródło
1

APL (NARS), 58 znaków, 116 bajtów

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

test:

  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
RosLuP
źródło
1

C, 120 bajtów

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 i wynik:

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

wyniki

0.520000 uppercase
0.580645 uppercase
0.555556 lowercase

Przypuszcza, że ​​zestaw znaków Ascii.

RosLuP
źródło
116 bajtów
ceilingcat
@ceilingcat możesz zaktualizować do 116 bajtów ... Dla mnie 120 bajtów, jeśli wystarczy ...
RosLuP