O objetivo deste code-golf é criar um código que permita ao usuário inserir uma string ASCII (contém apenas caracteres ASCII imprimíveis ), e seu programa gera a variante em minúscula dessa string.

Importante: você NÃO tem permissão para usar uma função interna que converta a string (ou apenas um caractere) em minúsculas (como ToLower()no .NET, strtolower()no PHP, ...)! Você tem permissão para usar todas as outras funções internas, no entanto.

Outra observação importante: A sequência de entrada não contém apenas caracteres maiúsculos. A sequência de entrada é uma mistura de caracteres maiúsculos, minúsculos, números e outros caracteres imprimíveis ASCII .

Boa sorte!

Shell - 10

Tradução da solução Perl de @ Gowtham usando /bin/tr.

tr A-Z a-z

Exemplo de execução:

% tr A-Z a-z <<<'Hello WORLD! @'
hello world! @

Python 2.7 - 30 (com abuso de regras terrível e sem desculpas)

raw_input().upper().swapcase()

Como uma edição anônima apontou, você pode fazer isso em 2726 no Python 3 :

input().upper().swapcase()

Estou flagrantemente abusando das regras aqui, mas ...

Importante: você NÃO tem permissão para usar uma função interna que converta a string (ou apenas um caractere) em minúsculas (como ToLower()no .NET, strtolower()no PHP, ...)! Você tem permissão para usar todas as outras funções internas, no entanto.

Isso pega as cordas e as cobre em maiúsculas . Em seguida, em uma chamada de método não relacionada, ele reverte as letras maiúsculas e minúsculas - para que todas as letras minúsculas se tornem maiúsculas ... e troque as letras maiúsculas para minúsculas .

Perl - 11 10 caracteres.

y/A-Z/a-z/

y///é o mesmo que tr///!

Em ação:

% perl -pe 'y/A-Z/a-z/' <<< 'Hello @ WORLD !'
hello @ world !

Befunge-98- 26 22 21 19

~:''-d2*/1-!' *+,#@

Baseia-se no fato de que (c-39)/26é 1apenas para códigos de caracteres de caracteres ASCII maiúsculos (assumindo divisão inteira). Para cada caractere c, imprima c + (((c-39)/26)==1)*' '.

Sessão de amostra:

% cfunge lower.b98
hello WORLD!
hello world!
This is a TEST!!11 az AZ @[`{
this is a test!!11 az az @[`{

Python 3, 58

print("".join(chr(ord(x)+('@'<x<'[')*32)for x in input()))

Ruby, 18 caracteres

Nada realmente interessante.

gets.tr'A-Z','a-z'

(executado no IRB)

Apenas por diversão: uma versão confusa:

$,=$* *' ';$;=$,.tr'A-Z','a-z';$><<$;

Execute assim:

c:\a\ruby>lowercase.rb Llamas are AMAZING!

Saída

llamas are amazing!

J - 30

'@Z'(]+32*1=I.)&.(a.&i.)1!:1]1

J é lido da direita para a esquerda, portanto, para dividir isso:

1. Solicitar entrada do usuário: 1!:1]1
2. Execute o algoritmo no espaço do ponto de código: &.(a.&i.)
3. Identifique o intervalo de caracteres para cada letra; os caracteres entre codepoints "@" e "Z" são considerados maiúsculas: 1=I..
4. Para cada ponto de código maiúsculo, adicione 32: ]+32* ...
5. Observe que a etapa (2) cria uma etapa implícita (5): começamos projetando do caractere para o domínio inteiro; portanto, agora que terminamos, mapeamos esses números inteiros de volta aos caracteres.

Obviamente, essa implementação específica considera apenas o ASCII; mas a abordagem poderia ser estendida para pelo menos o plano multilíngue básico em Unicode.

C 64 63 59 55 chars

main(c){while(c=getchar(),~c)putchar(c-65u<27?c+32:c);}

Golfscript - 17

Program:

{..64>\91<*32*+}%

Explanation:

1. {}% maps the code inside to every character in string.
2. .. copies the top of the stack (the character) twice.
3. 64> 1 if character code is greater than 64, else 0.
4. \ swaps the two items on the stack (gets the second copy of the letter, and stores the result of 64> in position two).
5. 91< checks to see if character code is less than 91. Similar to step 3.
6. * multiplies the results from steps 3 and 5 together. Only equal to 1, if both steps were true.
7. 32* multiplies the result of step 6 with 32. Will be 32 if step 6 was 1, else 0.
8. + add the result (either 32 or 0) onto the character code.

Example output:

echo HelLO @ WorLD | ruby golfscript.rb upper_to_lower.gs
hello @ world

Perl: 24 characters

s/[A-Z]/chr 32+ord$&/ge

Sample run:

bash-4.1$ perl -pe 's/[A-Z]/chr 32+ord$&/ge' <<< 'Hello @ WORLD !'
hello @ world !

Python (33)

If in doubt, use the shell.

import os;os.system('tr A-Z a-z')

Regrettably, this is still longer than Lego's solution.

DELPHI

const
  UpChars:set of AnsiChar = ['A'..'Z'];
var
  I: Integer;
begin
  SetLength(Result, Length(pString));
  for I := 1 to length(pstring) do
    Result[i] := AnsiChar((Integer(pString[i] in UpChars))*(Ord(pString[i])+32));
  WriteLn(Result);
end;

JavaScript - 109 104 (ES6: 95)

Thanks to some for the corrected version.

a=prompt();for(b=[i=0];c=a.charCodeAt(i);)b[i++]=String.fromCharCode(c|(c>64&c<91)*32);alert(b.join(""))

The following works if the browser supports ES6 function expressions:

alert(prompt().split("").map(c=>String.fromCharCode(c.charCodeAt()|(c>"@"&c<"[")*32)).join(""))

Perl 18

s/[A-Z]/$&|" "/eg

Algo como:

perl -pe 's/[A-Z]/$&|" "/eg'  <<<'are NOT allowed to: ToLower() in .NET, strtolower() in PHP'
are not allowed to: tolower() in .net, strtolower() in php

e

perl -pe 's/[A-Z]/$&|" "/eg' <<< "The input string Doesn't cOntaIn...( C0D3-@01F. ;-)"
the input string doesn't contain...( c0d3-@01f. ;-)

Para @FireFly :

perl -pe 's/[A-Z]/$&|" "/eg' <<< "Doesn't this translate @ to \` and [\]^_ to {|}~DEL? "
doesn't ... @ to ` and [\]^_ to {|}~del? 

não.

Mais genérico: 18 caracteres de qualquer maneira:

s/[A-Z]/$&|" "/eg

s/[A-Z]/$&^" "/eg

Isso não vai mudar nada no estado:

perl -pe 's/[A-Z]/$&^" "/eg' <<< "Doesn't ... @ to \` and [\]^_ to {|}~DEL? "
doesn't ... @ to ` and [\]^_ to {|}~del? 

Todos funcionam bem, mas a vantagem de mudar |(ou) por ^(xor) é que a mesma sintaxe poderia ser usado para toLower, toUpperouswapCase :

toUpper:

perl -pe 's/[a-z]/$&^" "/eg' <<< "Doesn't ... @ to \` and [\]^_ to {|}~DEL? "
DOESN'T ... @ TO ` AND [\]^_ TO {|}~DEL? 

e swapCase (18 + 1 = 19 caracteres) :

perl -pe 's/[a-z]/$&^" "/egi' <<< "Doesn't ... @ to \` and [\]^_ to {|}~DEL? "
dOESN'T ... @ TO ` AND [\]^_ TO {|}~del? 

javascript 80

"X".replace(/[A-Z]/g,function($){return String.fromCharCode($.charCodeAt()+32)})

(76 se você remover "X" )

com prompte alert- 92

alert(prompt().replace(/[A-Z]/g,function($){return String.fromCharCode($.charCodeAt()+32)}))

violino

Obrigado a @FireFly @some @ C5H8NNaO4 e @minitech

R

71 caracteres:

chartr(paste(LETTERS,collapse=""),paste(letters,collapse=""),scan(,""))

83 caracteres:

a=as.integer(charToRaw(scan(,"")))
b=a%in%(65:90)
a[b]=a[b]+32
rawToChar(as.raw(a))

Q, 18

.....

{x^ssr/[x]..Q`a`A}

Q (16)

.......

{x^(.Q.A!.Q.a)x}

PHP (42)

Execute a partir da linha de comando:

-R'echo@str_ireplace($a=range(a,z),$a,$argn);'

-R e as aspas simples não são contadas.

PowerShell: 69 65 64

Eu tentei meia dúzia de maneiras de fazer o Replace funcionar da maneira que eu queria, sem usar a [regex]::Replacesintaxe longa , mas não tive sorte. Se alguém tiver uma idéia do que pode funcionar, sugira.

Código de golfe:

[regex]::Replace((read-host),"[A-Z]",{[char](32+[char]"$args")})

Alterações do original:

• Reorganizou o último argumento para que [int]não seja mais necessário, por sugestão nos comentários.

Explicação:

(read-host) obtém a entrada do usuário.

[regex]::Replace(... )diz ao PowerShell para usar a correspondência de RegEx para executar operações de substituição em uma seqüência de caracteres.

"[A-Z]" corresponde a todas as letras maiúsculas.

{... }diz ao PowerShell para usar um script para determinar o valor de substituição.

[char]"$args" pega a correspondência atual e a digita como um caractere ASCII.

32+ converte o caractere em um número inteiro, representando o código ASCII e aumenta o valor em 32 - o que corresponderia ao código ASCII da letra minúscula correspondente.

[char](... )pega o valor resultante e o converte novamente em um caractere ASCII.

Demonstração do original:

(Versão atual testada - captura de tela ainda não publicada.)

k2, 15 bytes

eu sou super atrasado para este, mas achei legal assim mesmo.

{_ci 32+_ic x}'

Além disso:

Pitão, 10 bytes

Realmente não conta, porque o Pyth foi criado depois que este foi publicado. Ainda legal.

jkmC+32Cdw

05AB1E , 3 bytes

u.š

Porta da resposta do usuário @ user8777 Python 3 .

Experimente online.

Explicação:

u    # Convert the (implicit) input to uppercase
 .š  # Switch the case (upper to lower and vice-versa)
     # (and output the result implicitly)

Mas sem nenhum recurso de alteração de caso:

05AB1E , 12 11 bytes

ÇIS.u32*+çJ

-1 byte graças a @Emigna .

Experimente online.

Explicação:

Ç            # Get the unicode values of each character of the (implicit) input-String
 IS          # Get the input-string, split to characters again
   .u        # Check for each if it's uppercase or not (1 if truthy; 0 if falsey)
     32*     # Multiply that result by 32 (32 if truhy; 0 if falsey)
        +    # Add it to all the unicode values at the same indices in the list
         ç   # Convert the now modified unicode values back to characters
          J  # And join all characters together to a string again
             # (which is output implicitly as result)

Javascript, 105

prompt().split("").map(function(a){c=a.charCodeAt(0);return String.fromCharCode(c|(c-64?32:0))}).join("")

_{Na verdade, não havia nenhum formulário de saída especificado, portanto, execute-o no console Sim, o JavaScript é realmente detalhado com o código <-> string}

Ruby: 66

def l(s)s.bytes.map{|b|(65..90).include?(b)?b+32:b}.pack('c*');end

C # - 108

class P{static void Main(string[]a){foreach(var c in a[0])System.Console.Write(
(char)(c>64&&c<91?c+32:c));}}

Cerca de 70 apenas para o corpo do método.

Adicione 5 caracteres para incluir um LF / CR na saída:

class P{static void Main(string[]a){foreach(var c in a[0]+"\n")System.Console.Write(
(char)(c>64&&c<91?c+32:c));}}

Uma versão do LINQ seria mais curta:

class P{static void Main(string[]a){a[0].Any(c=>System.Console.Write(
(char)(c>64&&c<91?32+c:c))is P);}}

(103) .. exceto que requer using System.Linq;(total: 121).

Haskell - 58

p x|(elem x['A'..'Z'])=[x..]!!32|1<2=x
main=interact$map p

Python 3-70

Atualizado para as alterações do OP.

Eu sou um novato em Python, então qualquer crítica é bem-vinda.

print("".join(chr(ord(c)+32) if 64<ord(c)<91 else c for c in input()))

Perl, 9 + 1 (para sinalizador -p) = 10

$_="\L$_"

\L foi especificamente questionado e permitido, porque, mesmo sendo incorporado, não é uma função.

Powershell, 53 49 bytes

-4 bytes graças a @AdmBorkBork

-join($args|% t*y|%{[char](32*($_-in65..90)+$_)})

Script de teste:

$f = {

-join($args|% t*y|%{[char](32*($_-in65..90)+$_)})

}

@(
    ,("Hello WORLD from PowerShell", "hello world from powershell")
) | % {
    $a,$e = $_
    $r = &$f $a
    "$($r-eq$e): $r"
}

Saída:

True: hello world from powershell

Código de máquina 8086, 14 bytes

Montado:

AC 3C 41 7C 06 3C 5A 7F 02 0C 20 AA E2 F2

Listagem desmontada:

 ; Lowercase a string
 ; Input: string: SI, length: CX
 ; Output: string: DI
 TOLOW  MACRO   
        LOCAL _LOOP, _STORE
       _LOOP:
 AC         LODSB           ; load byte from [SI] into AL, advance SI 
 3C 41      CMP  AL, 'A'    ; is char less than 'A'? 
 7C 06      JL   _STORE     ; if so, do not convert 
 3C 5A      CMP  AL, 'Z'    ; is char greater than 'Z'? 
 7F 02      JG   _STORE     ; if so, do not convert 
 0C 20      OR   AL, 020H   ; lowercase the char 
       _STORE:
 AA         STOSB           ; store char to [DI], advance DI 
 E2 F2      LOOP _LOOP      ; continue loop through string 

Implementado como uma MACRO(essencialmente uma função). String de entrada SI, comprimento em CX. String de saída emDI .

Saída do programa de teste do PC DOS:

Baixe e teste o programa de exemplo TOLOW.COM .