Proporção de letras maiúsculas para minúsculas


28

Nesse desafio, você e seus amigos estão debatendo sobre qual caso é melhor, maiúsculo ou minúsculo. Para descobrir, você escreve um programa para fazer isso por você.

Como os esolangs assustam seus amigos e o código detalhado o assusta, seu código precisará ser o mais curto possível.


Exemplos

PrOgRaMiNgPuZzLeS & CoDe GoLf
0.52 uppercase

DowNGoAT RiGHtGoAt LeFTGoat UpGoAT
0.58 uppercase

Foo BaR Baz
0.56 lowercase

Especificações

A entrada consistirá apenas em caracteres ASCII. Todos os caracteres não alfabéticos devem ser ignorados. Haverá pelo menos 1 caractere de cada caso

A saída deve ser a quantidade do caso que aparece com mais frequência sobre a quantidade total de caracteres alfabéticos. Deve ser um decimal preciso com pelo menos 2 casas decimais. Se maiúsculas aparecerem com mais frequência, a saída deve terminar com uppercase, ou lowercase.

Nunca haverá a mesma quantidade de caracteres maiúsculos e minúsculos.


7
Esolangs não assustam meus amigos. Isso significa que meu código pode ser muito detalhado?
Alex A.

@AlexA. código detalhado assusta você, portanto, seu código também precisará ser jogado no golfe.
Downgoat

16
Ah, claro, eu tinha esquecido meus pesadelos recorrentes sobre Java.
Alex A.

4
Haverá entrada com apenas um caso?
manatwork

11
"Preciso com pelo menos 2 casas decimais" requer a impressão de pelo menos duas casas decimais ou pode ser deixado de fora uma segunda casa decimal?
hvd

Respostas:


2

Pitão - 40 bytes

Esta é a primeira vez que eu já usei formatação de string vetorizada, o que é bem legal.

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

Conjunto de Teste .


7

JavaScript (ES6) 87 bytes

Editar 1 byte salvo thx ETHProductions
Editar mais 1 byte salvo thx l4me

Uma função anônima. Longo, mas não encontrei uma maneira de jogar golfe mais

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

Menos golfe

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
)

Eu acredito que você poderia salvar um byte usando &&` ${t-l>l?1-l/t+'upp':l/t+'low'}ercase` .
ETHproductions

Além disso, c=>l+=++t&&c>'Z'funcionaria, eu acho ...?
ETHproductions

@ETHproductions sua primeira sugestão não parece útil, o segundo é inteligente, thx
edc65

11
Podemos ver a versão não-gasta com uma explicação?
Cyoce

@Cyoce explicação adicional - É simples, na verdade
edc65

4

CJam, 47 45 bytes

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

Experimente online.

Não jogar golfe por muito tempo ...

Explicação

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.

4

Japonês , 58 bytes

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

(Observação: o SE retirou um caractere especial antes Ö, então clique no link para obter o código adequado)


Bom trabalho! Seu primeiro regex (incluindo os cifrões) pode ser substituído por "[a-z]"e o segundo por "A-Za-z". 0.5é igual a ½. Você também pode remover as aspas finais.
ETHproductions

Com as alterações mencionadas e a compactação de cadeias, recebo 58: A=Uf"[a-z]" l /Uf"[A-Za-z]" l)>½?A+" low":1-A+" upp" +`\x80ÖÐVocê pode obter a versão bruta dos últimos três bytes com Oc"ercase.
ETHproductions

@Eth \x80não pareceu fazer nada, e ÖÐproduziu "case" ... Talvez alguns caracteres invisíveis que foram truncados? Btw, desde o meu próprio mod, obrigado pelas dicas #
nicael

@ETH Ok, conseguiu usar esse Invisi-char :)
nicael

Infelizmente, as barras invertidas precisam ser duplicadas dentro de cadeias para que o analisador de expressões regulares funcione. Nestes casos, "\w"simplesmente corresponde a todos os ws, e "\\w"combina todos A-Za-z0-9_. Então eu acho que você precisará manter "[a-z]".
ETHproductions

4

R , 133 123 118 108 106 105 104 bytes

Golpeou 10 bytes graças a @ ovs, 8 graças a @ Giuseppe e 10 novamente a @ngm. Neste ponto, é realmente um esforço colaborativo em que eu forneço os bytes e outros os tiram;)

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

Experimente online!


raspou mais 1 byte.
21418 JayCe

3

MATL , 49 50 bytes

Usa a versão atual (4.1.1) do idioma, anterior ao desafio.

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

Exemplos

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

Explicação

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'

3

Julia, 76 74 bytes

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

Esta é uma função lambda que aceita uma string e retorna uma string. Para chamá-lo, atribua-o a uma variável.

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

Economizou 2 bytes graças a edc65!


11
U certamente pode salvar 2 bytes usando em ercasevez decase
edc65

@ edc65 Ótima idéia, obrigado!
Alex A.

3

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

Uso:

# 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

2
Blocos de código de ataque? Isso é algo novo ...
Bojidar Marinov

11
Perca 3 caracteres trocando o ternário pelo máximo ("0,55 upp", "0,45 baixo"): Experimente
Phil H

3

C #, 135 bytes

Requer:

using System.Linq;

Função real:

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

Com explicação:

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
}

3

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'

11
Você pode salvar 2 bytes substituindo ['upp','low'][n<.5]por 'ulpopw'[n<.5::2]e mais 3 substituindo [n,1-n][n<.5]por max(n,1-n).
PurkkaKoodari



2

PHP, 140 129 caracteres

Minha primeira partida de golfe - nada mal para um idioma 'padrão', não é? :-)

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

Encurtado para 129 caracteres graças a @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;}

Com comentários:

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

Dado o $u+=…, suponho que você já tenha o error_reportingpadrão, silenciando avisos. Em seguida, retire algumas citações: ' '.($u<$l?low:upp).ercase.
manatwork

Se você tiver apenas uma instrução a repetir com for, poderá remover os aparelhos ao redor dela. for($i=65;$i<91;$u+=$a[$i++])$l+=$a[$i+32];
manatwork

Com o preço de outro aviso, você pode poupar a forinicialização da variável de controle fazendo um loop de 0..26 em vez de 65..91:for(;$i<26;$u+=$a[$i+++65])$l+=$a[$i+97];
manatwork

Uau, obrigado @manatwork, eu não sabia o quão tolerante é o PHP! : D O segundo é muito inteligente. Eu implementei as suas ideias, trazendo a contagem para 140-4-5-2 = 129 :-)
Christallkeks

2

Ruby, 81 + 1 = 82

Com bandeira -p,

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

É uma sorte que, para números entre 0 e 1, a classificação lexicográfica seja igual à classificação numérica.


2

Lisp comum, 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"))

Experimente online!


No teste, 0,52 está em maiúsculas e não em minúsculas ...
RosLuP

11
@RosLuP, corrigido, muito obrigado!
Renzo

1

Gema, 125 caracteres

\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

Exemplo de execução:

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

-1 porque esolangs assusta seus amigos. (jk, votado)
ev3commander

1

Sério, 58 bytes

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

Hex Dump:

22207570702222206c6f77226b2265726361736522402bbb2c3b3ba33b
962bef402d402d3b6c40a3402d6c2f3b312d6b3b693c40bd405a45ee6a

Funciona apenas no intérprete para download ... o online ainda está quebrado.

Explicação:

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

1

Pitão, 45 bytes

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

Experimente online. Suíte de teste.

Explicação

             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"

1

CoffeeScript, 104 caracteres

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

A coffeescript estava inicialmente tentando passar o valor de retorno pretendido como argumento para o valor "r", que falhou e foi super irritante porque r era um número, não uma função. Eu consegui contornar isso colocando um &&entre as instruções para separá-las.


1

Pyth, 54 53

Um byte salvo graças a @Maltysen

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

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

,<any><any>é um comando de dois arity que é o mesmo que [<any><any>)o que pode poupar um byte
Maltysen

1

Ruby, 97 caracteres

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

Exemplo de execução:

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

1

05AB1E , 28 bytes

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

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

1

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 criando uma porta da resposta C # .NET do @ProgramFOX ' .

Experimente online.

Explicação:

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"

1

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



1

Kotlin , 138 bytes

Código

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

Uso

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

1

Pitão, 40 39 bytes

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

Experimente aqui

Explicação

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.

1

Núcleo do PowerShell , 134 128 bytes

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

Experimente online!

Obrigado, Veskah , por salvar seis bytes convertendo a função em um filtro!


11
Você pode salvar dois bytes livres, tornando-a um filtro em vez de uma função, ou seja, filtro F (código)
Veskah

Eu nunca soube que isso era uma coisa! Obrigado, Veskah!
Jeff Freeman

1

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}

Experimente online!


1

APL (NARS), 58 caracteres, 116 bytes

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

teste:

  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

1

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

teste e resultado:

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

resultados

0.520000 uppercase
0.580645 uppercase
0.555556 lowercase

Supõe o conjunto de caracteres Ascii.



@ceilingcat você pode atualizar o seu para que 116 bytes ... Este 120 bytes para mim, se é suficiente ...
RosLuP
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.