El objetivo de este código de golf es crear un código que permita al usuario ingresar una cadena ASCII (contiene solo caracteres ASCII imprimibles ), y su programa genera la variante en minúscula de esta cadena.

Importante: ¡NO está permitido usar una función incorporada que convierta la cadena (o solo un carácter) a minúsculas (como ToLower()en .NET, strtolower()en PHP, ...)! Sin embargo, puede usar todas las demás funciones integradas.

Otra nota importante: la cadena de entrada no contiene solo caracteres en mayúscula. La cadena de entrada es una combinación de mayúsculas, minúsculas, números y otros caracteres imprimibles ASCII .

¡Buena suerte!

Shell - 10

Traducción de la solución Perl de @Gowtham usando /bin/tr.

tr A-Z a-z

Ejecución de muestra:

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

Python 2.7 - 30 (con abuso de reglas terrible y sin complejos)

raw_input().upper().swapcase()

Como señaló una edición anónima, puedes hacerlo en 2726 en Python 3 :

input().upper().swapcase()

Estoy abusando flagrantemente de las reglas aquí, pero ...

Importante: ¡NO está permitido usar una función incorporada que convierta la cadena (o solo un carácter) a minúsculas (como ToLower()en .NET, strtolower()en PHP, ...)! Sin embargo, puede usar todas las demás funciones integradas.

Esto toma las cuerdas y las convierte en mayúsculas . Luego, en una llamada a un método muy poco relacionado, invierte las mayúsculas y minúsculas de la cadena, de modo que cualquier letra minúscula se convierta en mayúscula ... y cambie las letras mayúsculas por minúsculas .

Perl - 11 10 caracteres.

y/A-Z/a-z/

y///es igual que tr///!

En acción:

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

Befunge-98-26 22 21 19

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

Se basa en el hecho de que (c-39)/26es 1solo para códigos de caracteres de caracteres ASCII en mayúsculas (suponiendo la división de enteros). Para cada personaje c, imprimir c + (((c-39)/26)==1)*' '.

Sesión de muestra:

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

Pitón 3, 58

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

Ruby, 18 caracteres

Nada realmente interesante

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

(ejecutar en IRB)

Solo por diversión: una versión confusa:

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

Corre así:

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

Salida

llamas are amazing!

J - 30

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

J se lee de derecha a izquierda, así que para desglosar esto:

1. Solicitar al usuario la entrada: 1!:1]1
2. Realizar algoritmo en código-punto-espacio: &.(a.&i.)
3. Identificar el rango de caracteres para cada letra; los caracteres entre los puntos de código "@" y "Z" son considerados mayúsculas: 1=I..
4. Para cada punto de código en mayúscula, agregue 32: ]+32* ...
5. Tenga en cuenta que el paso (2) crea un paso implícito (5): comenzamos proyectando desde el carácter al dominio de enteros, por lo que ahora que hemos terminado, asignamos esos enteros de nuevo a los caracteres.

Obviamente, esta implementación particular solo considera ASCII; pero el enfoque podría extenderse al menos al plano multilingüe básico en Unicode.

C 64 63 59 55 caracteres

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

Golfscript - 17

Programa:

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

Explicación:

1. {}% asigna el código dentro de cada carácter en cadena.
2. .. copia la parte superior de la pila (el personaje) dos veces.
3. 64> 1 si el código de caracteres es mayor que 64, de lo contrario 0.
4. \intercambia los dos elementos en la pila (obtiene la segunda copia de la carta y almacena el resultado 64>en la posición dos).
5. 91< comprueba si el código de caracteres es menor que 91. Similar al paso 3.
6. *multiplica los resultados de los pasos 3 y 5 juntos. Solo igual a 1, si ambos pasos eran verdaderos.
7. 32* multiplica el resultado del paso 6 por 32. Será 32 si el paso 6 fue 1, de lo contrario 0.
8. + agregue el resultado (ya sea 32 o 0) en el código de caracteres.

Salida de ejemplo:

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

Perl: 24 caracteres

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

Ejecución de muestra:

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

Pitón (33)

En caso de duda, use el caparazón.

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

Lamentablemente, esto es aún más largo que la solución de Lego.

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)

Gracias a algunos por la versión corregida.

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

Lo siguiente funciona si el navegador admite expresiones de función ES6:

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

y

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? 

no.

Más genérico: 18 caracteres de todos modos:

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

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

Esto no cambiará nada en el estado:

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

Todo funciona bien, pero la ventaja de cambiar |(o) por ^(xor) es que la misma sintaxis podría usarse para toLower, toUppero swapCase:

superior:

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

y 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 si quitas "X")

con prompty alert- 92

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

violín

gracias a @FireFly @some @ C5H8NNaO4 y @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)

Ejecutar desde la línea de comando:

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

-R y las comillas simples no se cuentan.

PowerShell: 69 65 64

He intentado media docena de formas para hacer que Reemplazar funcione de la manera que quiero sin usar la [regex]::Replacesintaxis larga , pero no he tenido suerte. Si alguien más tiene una idea de lo que podría funcionar, sugiéralo.

Código de golf:

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

Cambios del original:

• Se reorganizó el último argumento para que [int]ya no sea necesario, por sugerencia en los comentarios.

Explicación:

(read-host) obtiene la entrada del usuario.

[regex]::Replace(... )le dice a PowerShell que use la coincidencia RegEx para realizar operaciones de reemplazo en una cadena.

"[A-Z]" coincide con todas las letras mayúsculas.

{... }le dice a PowerShell que use un script para determinar el valor de reemplazo.

[char]"$args" toma la coincidencia actual y la escribe como un carácter ASCII.

32+ convierte el carácter en un entero, que representa el código ASCII, y aumenta el valor en 32, lo que coincidiría con el código ASCII de la letra minúscula correspondiente.

[char](... )toma el valor resultante y lo convierte de nuevo a un carácter ASCII.

Demo del original:

(Versión actual probada: la captura de pantalla aún no se ha publicado).

k2, 15 bytes

Llegué muy tarde a este, pero me pareció genial de todos modos.

{_ci 32+_ic x}'

También:

Pyth, 10 bytes

Realmente no cuenta porque Pyth fue creado después de que esto fue publicado. Aún genial

jkmC+32Cdw

05AB1E , 3 bytes

u.š

Puerto de @ user8777 Python 3 respuesta .

Pruébalo en línea.

Explicación:

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

Pero sin ningún tipo de alteración de mayúsculas y minúsculas:

05AB1E , 12 11 bytes

ÇIS.u32*+çJ

-1 byte gracias a @Emigna .

Pruébalo en línea.

Explicación:

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

_{En realidad, no se especificó ningún formulario de salida, así que ejecútelo en la consola Sí, JavaScript realmente es detallado con charcode <-> string}

Rubí: 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));}}

Alrededor de 70 solo para el cuerpo del método.

Agregue 5 caracteres para incluir un LF / CR en la salida:

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

Una versión de LINQ sería más corta:

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) ... excepto que requiere 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

Actualizado para los cambios de OP.

Soy un novato en Python, por lo que cualquier crítica es bienvenida.

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

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

$_="\L$_"

\L se le preguntó específicamente y se le permitió, porque a pesar de que está integrado, no es una función.

Powershell, 53 49 bytes

-4 bytes gracias @AdmBorkBork

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

Script de prueba:

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

Salida:

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

Listado sin ensamblar:

 ; 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 a MACRO(esencialmente una función). Cadena de entrada SI, longitud CX. Cadena de salida en DI.

Salida del programa de prueba PC DOS:

Descargue y pruebe el programa de ejemplo TOLOW.COM .