该代码高尔夫球的目标是创建一个代码，该代码允许用户输入ASCII字符串（仅包含可打印的ASCII字符），并且程序将输出此字符串的小写字母。

重要提示：不允许使用将字符串（或仅一个字符）转换为小写的内置函数（例如ToLower().NET，strtolower()PHP等）！但是，您可以使用所有其他内置函数。

另外要注意：输入字符串不包含仅大写字符。输入字符串是大写字符，小写字符，数字和其他ASCII可打印字符的混合。

祝好运！

贝壳-10

使用转换@Gowtham的Perl解决方案/bin/tr。

tr A-Z a-z

样品运行：

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

Python 2.7-30（严重且毫无歉意的规则滥用）

raw_input().upper().swapcase()

匿名编辑指出，您可以在 27在Python 3中为26：

input().upper().swapcase()

我在这里公然滥用规则，但是...

重要提示：不允许使用将字符串（或仅一个字符）转换为小写的内置函数（例如ToLower().NET，strtolower()PHP等）！但是，您可以使用所有其他内置函数。

这将使字符串变暗并将其转换为大写。然后，在一个非常不相关的方法调用中，它反转字符串的大小写-以便所有小写字母变为大写字母...并将任何大写字母交换为小写字母。

Perl - 11个10个字符。

y/A-Z/a-z/

y///与tr///！

实际上：

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

Befunge-98-26 22 21 19

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

依赖于一个事实，即(c-39)/26是1只为大写ASCII字符（假定整数除法）字符代码。对于每个字符c，请打印出来c + (((c-39)/26)==1)*' '。

会话示例：

% 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个字符

没什么好有趣的。

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

（在IRB中运行）

只是为了好玩：一个令人困惑的版本：

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

像这样运行：

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

输出量

llamas are amazing!

J-30

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

J是从右到左读取的，因此可以将其分解：

1. 提示用户输入： 1!:1]1
2. 在代码点空间中执行算法： &.(a.&i.)
3. 确定每个字母的字符范围；代码点“ @”和“ Z”之间的字符被认为是大写的：1=I.。
4. 对于每个大写代码点，添加32： ]+32* ...
5. 请注意，步骤（2）创建了一个隐式步骤（5）：我们从将字符投影到整数域开始，所以现在我们完成了，将这些整数映射回字符。

显然，此特定实现只考虑了ASCII。但是该方法至少可以扩展到Unicode中的基本多语言平面。

C 64 63 59 55个字符

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

Golfscript-17

程序：

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

说明：

1. {}% 将内部代码映射到字符串中的每个字符。
2. .. 复制堆栈顶部（字符）两次。
3. 64> 如果字符代码大于64，则为1，否则为0。
4. \交换堆栈上的两个项目（获取信函的第二份副本，并将结果存储64>在位置2中）。
5. 91< 检查字符代码是否小于91。类似于步骤3。
6. *将步骤3和5的结果相乘。如果两个步骤都为真，则仅等于1。
7. 32* 将步骤6的结果与32相乘。如果步骤6为1，则结果为32，否则为0。
8. + 将结果（32或0）添加到字符代码上。

输出示例：

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

Perl：24个字符

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

样品运行：

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

巨蟒（33）

如有疑问，请使用外壳。

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

遗憾的是，这仍然比Lego的解决方案更长。

德尔菲

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）

感谢一些正确的版本。

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

如果浏览器支持ES6函数表达式，则可以使用以下功能：

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

Perl 18

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

就像是：

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

和

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

对于@FireFly：

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

没有。

更通用：反正18个字符：

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

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

这不会改变任何状态：

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

所有的工作很好，但改变的好处|（或）由^（XOR）是同样的语法可以用于toLower，toUpper或swapCase：

toUpper：

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

和swapCase （18 + 1 = 19个字符）：

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如果您移除 "X")

with prompt and alert - 92

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

fiddle

thanks to @FireFly @some @C5H8NNaO4 and @minitech

R

71 characters:

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

83 characters:

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)

Run from the command line:

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

-R and the single quotes are not counted.

PowerShell: 69 65 64

I've tried a half-dozen ways to get Replace to work the way I want it to without using the long [regex]::Replace syntax, but I haven't had any luck. If anyone else has an idea of what might work, please do suggest it.

Golfed code:

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

Changes from original:

• Rearranged last argument so that [int] is no longer needed, per suggestion in comments.

Explanation:

(read-host) gets the user input.

[regex]::Replace(...) tells PowerShell to use RegEx matching to perform replacement operations on a string.

"[A-Z]" matches all uppercase letters.

{...} tells PowerShell to use a script to determine the replacement value.

[char]"$args" takes the current match and types it as an ASCII character.

32+ converts the character to an integer, representing the ASCII code, and increases the value by 32 - which would match ASCII code of the corresponding lowercase letter.

[char](...) takes the resulting value and converts it back to an ASCII character.

Demo of original:

(Current version tested - screenshot not yet posted.)

k2, 15 bytes

I am super late to this one, but I found this cool anyway.

{_ci 32+_ic x}'

Also:

Pyth, 10 bytes

Doesn't really count because Pyth was created after this was posted. Still cool.

jkmC+32Cdw

05AB1E, 3 bytes

u.š

Port of @user8777 Python 3 answer.

Try it online.

Explanation:

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

But without any case-altering builtins:

05AB1E, 12 11 bytes

ÇIS.u32*+çJ

-1 byte thanks to @Emigna.

Try it online.

Explanation:

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

_{Actually ther was no output form specified, so run it in console Yea, JavaScript really is verbose with charcode <-> 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));}}

About 70 for just the method body.

Add 5 chars to include a LF/CR in the output:

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

A LINQ version would be shorter:

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) .. except that it requires 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

Updated for OP's changes.

I'm a Python newbie, so any critique is welcome.

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

Perl, 9 + 1 (for -p flag) = 10

$_="\L$_"

\L was specifically asked about and allowed, because even though it's a built-in, it's not a function.

Powershell, 53 49 bytes

-4 bytes thanks @AdmBorkBork

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

Test script:

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

Output:

True: hello world from powershell

8086 machine code, 14 bytes

Assembled:

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

Unassembled listing:

 ; 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 

Implemented as a MACRO (essentially a function). Input string in SI, length in CX. Output string in DI.

Output from PC DOS test program:

Download and test TOLOW.COM example program.