Tujuan golf kode ini adalah membuat kode yang memungkinkan pengguna memasukkan string ASCII (hanya berisi karakter ASCII yang dapat dicetak ), dan program Anda menghasilkan varian huruf kecil dari string ini.

Penting: Anda TIDAK diizinkan menggunakan fungsi bawaan yang mengubah string (atau hanya satu karakter) menjadi huruf kecil (seperti ToLower()dalam .NET, strtolower()dalam PHP, ...)! Anda diizinkan menggunakan semua fungsi bawaan lainnya.

Catatan penting lainnya: String input tidak hanya berisi karakter huruf besar. String input adalah campuran karakter huruf besar, huruf kecil, angka dan karakter ASCII lainnya yang dapat dicetak .

Semoga berhasil!

Shell - 10

Terjemahan dari solusi Perl @ Gowtham menggunakan /bin/tr.

tr A-Z a-z

Contoh dijalankan:

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

Python 2.7 - 30 (dengan penyalahgunaan aturan yang mengerikan dan tidak menyesal)

raw_input().upper().swapcase()

Seperti yang ditunjukkan oleh hasil edit anonim, Anda dapat melakukannya 2726 dalam Python 3 :

input().upper().swapcase()

Saya terang-terangan menyalahgunakan aturan di sini, tapi ...

Penting: Anda TIDAK diizinkan menggunakan fungsi bawaan yang mengubah string (atau hanya satu karakter) menjadi huruf kecil (seperti ToLower()dalam .NET, strtolower()dalam PHP, ...)! Anda diizinkan menggunakan semua fungsi bawaan lainnya.

Ini mengambil string dan menutupinya ke huruf besar . Kemudian dalam pemanggilan metode yang sangat tidak terkait, itu membalik case dari string - sehingga setiap huruf kecil menjadi huruf besar ... dan menukar setiap huruf besar menjadi huruf kecil .

Perl - 11 10 karakter.

y/A-Z/a-z/

y///sama dengan tr///!

Beraksi:

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

Befunge-98 - 26 22 21 19

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

Bergantung pada kenyataan bahwa (c-39)/26ini 1hanya untuk kode karakter dari karakter ASCII huruf besar (dengan asumsi pembagian integer). Untuk setiap karakter c, cetak c + (((c-39)/26)==1)*' '.

Sesi sampel:

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

Tidak ada yang benar-benar menarik.

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

(dijalankan di IRB)

Hanya untuk bersenang-senang: versi yang membingungkan:

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

Jalankan seperti ini:

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

Keluaran

llamas are amazing!

J - 30

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

J dibaca kanan-ke-kiri, jadi untuk memecah ini:

1. Pengguna yang cepat untuk input: 1!:1]1
2. Lakukan algoritma dalam kode-titik-ruang: &.(a.&i.)
3. Identifikasi rentang karakter untuk setiap huruf; karakter antara codepoints "@" dan "Z" dianggap huruf besar: 1=I..
4. Untuk setiap codepoint huruf besar, tambahkan 32: ]+32* ...
5. Perhatikan bahwa langkah (2) menciptakan langkah implisit (5): kami mulai dengan memproyeksikan dari karakter ke domain integer, jadi sekarang setelah kami selesai, kami memetakan bilangan bulat tersebut kembali ke karakter.

Jelas implementasi khusus ini hanya mempertimbangkan ASCII; tetapi pendekatan tersebut dapat diperluas setidaknya ke pesawat multibahasa dasar di Unicode.

C 64 63 59 55 karakter

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

Golfscript - 17

Program:

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

Penjelasan:

1. {}% memetakan kode di dalam ke setiap karakter dalam string.
2. .. menyalin bagian atas tumpukan (karakter) dua kali.
3. 64> 1 jika kode karakter lebih besar dari 64, atau 0.
4. \menukar kedua item di tumpukan (mendapatkan salinan kedua surat itu, dan menyimpan hasilnya 64>di posisi dua).
5. 91< memeriksa untuk melihat apakah kode karakter kurang dari 91. Mirip dengan langkah 3.
6. *mengalikan hasil dari langkah 3 dan 5 bersamaan. Hanya sama dengan 1, jika kedua langkah itu benar.
7. 32* gandakan hasil langkah 6 dengan 32. Akan menjadi 32 jika langkah 6 adalah 1, jika tidak 0.
8. + tambahkan hasilnya (32 atau 0) ke kode karakter.

Contoh output:

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

Perl: 24 karakter

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

Contoh dijalankan:

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

Python (33)

Jika ragu, gunakan shell.

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

Sayangnya, ini masih lebih lama dari solusi 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)

Terima kasih beberapa untuk versi yang diperbaiki.

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

Berikut ini berfungsi jika browser mendukung ekspresi fungsi ES6:

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

Perl 18

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

Sesuatu seperti:

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

dan

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

Untuk @FireFly :

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

tidak.

Lebih umum: 18 karakter:

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

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

Ini tidak akan mengubah apa pun dalam status:

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

Semua berfungsi dengan baik, tetapi keuntungan dari mengubah |(atau) oleh ^(xor) adalah bahwa sintaks yang sama dapat digunakan untuk toLower, toUpperatau swapCase:

ke Atas:

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

dan swapCase (18 + 1 = 19 karakter) :

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 if you remove "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.