L'obiettivo di questo code-golf è quello di creare un codice che consenta all'utente di immettere una stringa ASCII (contiene solo caratteri ASCII stampabili ) e il programma emette la variante minuscola di questa stringa.

Importante: NON ti è permesso usare una funzione integrata che converte la stringa (o solo un carattere) in minuscolo (come ToLower()in .NET, strtolower()in PHP, ...)! Tuttavia, puoi utilizzare tutte le altre funzioni integrate.

Un'altra nota importante: la stringa di input non contiene solo caratteri maiuscoli. La stringa di input è un mix di caratteri maiuscoli, caratteri minuscoli, numeri e altri caratteri ASCII stampabili .

In bocca al lupo!

Shell - 10

Traduzione della soluzione Perl di @ Gowtham utilizzando /bin/tr.

tr A-Z a-z

Esecuzione di esempio:

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

Python 2.7 - 30 (con abuso di regole terribile e non dispiaciuto)

raw_input().upper().swapcase()

Come ha sottolineato una modifica anonima, puoi farlo 2726 in Python 3 :

input().upper().swapcase()

Sto abusando palesemente delle regole qui, ma ...

Importante: NON ti è permesso usare una funzione integrata che converte la stringa (o solo un carattere) in minuscolo (come ToLower()in .NET, strtolower()in PHP, ...)! Tuttavia, puoi utilizzare tutte le altre funzioni integrate.

Questo prende le stringhe e le copre in maiuscolo . Quindi, in una chiamata di metodo molto non correlata, inverte il caso della stringa, in modo che eventuali lettere minuscole diventino lettere maiuscole ... e scambia lettere maiuscole con lettere minuscole .

Perl - 11 10 caratteri.

y/A-Z/a-z/

y///è lo stesso di tr///!

In azione:

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

Befunge-98 - 26 22 21 19

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

Si basa sul fatto che (c-39)/26è 1solo per i codici carattere di caratteri ASCII maiuscoli (presupponendo la divisione di numeri interi). Per ogni personaggio c, stampa c + (((c-39)/26)==1)*' '.

Sessione di esempio:

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

Niente di veramente interessante.

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

(eseguito in IRB)

Solo per divertimento: una versione confusa:

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

Esegui in questo modo:

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

Produzione

llamas are amazing!

J - 30

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

J viene letto da destra a sinistra, quindi per scomporlo:

1. Richiedi all'utente input: 1!:1]1
2. Esegui algoritmo nello spazio punto-codice: &.(a.&i.)
3. Identificare l'intervallo di caratteri per ogni lettera; i caratteri tra i punti di codice "@" e "Z" sono considerati maiuscoli:1=I. .
4. Per ogni punto di codice maiuscolo, aggiungere 32: ]+32* ...
5. Nota che il passaggio (2) crea un passaggio implicito (5): abbiamo iniziato proiettando dal dominio del carattere al numero intero, quindi ora che abbiamo finito, mappiamo quei numeri interi sui caratteri.

Ovviamente questa particolare implementazione considera solo ASCII; ma l'approccio potrebbe essere esteso almeno al piano multilingue di base in Unicode.

C 64 63 59 55 caratteri

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

Golfscript - 17

Programma:

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

Spiegazione:

1. {}% associa il codice all'interno di ogni carattere nella stringa.
2. .. copia la parte superiore della pila (il personaggio) due volte.
3. 64> 1 se il codice carattere è maggiore di 64, altrimenti 0.
4. \ scambia i due oggetti in pila (ottiene la seconda copia della lettera e memorizza il risultato di 64> nella posizione due).
5. 91< controlla se il codice carattere è inferiore a 91. Simile al passaggio 3.
6. *moltiplica i risultati dai passaggi 3 e 5 insieme. Solo uguale a 1, se entrambi i passaggi fossero veri.
7. 32* moltiplica il risultato del passaggio 6 per 32. Sarà 32 se il passaggio 6 fosse 1, altrimenti 0.
8. + aggiungi il risultato (32 o 0) sul codice carattere.

Esempio di output:

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

Perl: 24 caratteri

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

Esecuzione di esempio:

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

Python (33)

In caso di dubbio, utilizzare la shell.

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

Purtroppo, questo è ancora più lungo della soluzione di 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)

Grazie ad alcuni per la versione corretta.

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

Quanto segue funziona se il browser supporta le espressioni di funzione ES6:

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

Perl 18

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

Qualcosa di simile a:

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

Per @FireFly :

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

no.

Più generico: 18 caratteri comunque:

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

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

Questo non cambierà nulla nello stato:

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

Tutto funziona bene, ma il vantaggio di cambiare |(o) con ^(xor) è che la stessa sintassi potrebbe essere usata per toLower, toUppero swapCase:

toupper:

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

e swapCase (18 + 1 = 19 caratteri) :

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 rimuovi "X" )

con prompte alert- 92

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

violino

grazie a @FireFly @some @ C5H8NNaO4 e @minitech

R

71 caratteri:

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

83 caratteri:

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)

Esegui dalla riga di comando:

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

-R e le virgolette singole non vengono conteggiate.

PowerShell: 69 65 64

Ho provato una mezza dozzina di modi per far sì che Replace funzioni nel modo che preferisco senza usare la [regex]::Replacesintassi lunga , ma non ho avuto fortuna. Se qualcun altro ha idea di cosa potrebbe funzionare, per favore, suggeriscilo.

Codice golfizzato:

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

Modifiche rispetto all'originale:

• Riorganizzato l'ultimo argomento in modo che [int]non sia più necessario, per suggerimento nei commenti.

Spiegazione:

(read-host) ottiene l'input dell'utente.

[regex]::Replace(... )dice a PowerShell di utilizzare la corrispondenza RegEx per eseguire operazioni di sostituzione su una stringa.

"[A-Z]" corrisponde a tutte le lettere maiuscole.

{... }dice a PowerShell di utilizzare uno script per determinare il valore di sostituzione.

[char]"$args" prende la corrispondenza corrente e la digita come carattere ASCII.

32+ converte il carattere in un numero intero, che rappresenta il codice ASCII, e aumenta il valore di 32, che corrisponderebbe al codice ASCII della lettera minuscola corrispondente.

[char](...) prende il valore risultante e lo converte in un carattere ASCII.

Demo dell'originale:

(Versione corrente testata - screenshot non ancora pubblicato.)

k2, 15 byte

Sono super- tardi per questo, ma ho trovato comunque questo freddo.

{_ci 32+_ic x}'

Anche:

Pyth, 10 byte

Non conta davvero perché Pyth è stato creato dopo che questo è stato pubblicato. Ancora bello.

jkmC+32Cdw

05AB1E , 3 byte

u.š

Porta della risposta @ user8777 Python 3 .

Provalo online.

Spiegazione:

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

Ma senza alcun builtin che modifica il caso:

05AB1E , 12 11 byte

ÇIS.u32*+çJ

-1 byte grazie a @Emigna .

Provalo online.

Spiegazione:

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

_{In realtà non è stato specificato alcun modulo di output, quindi eseguilo nella console Sì, JavaScript è davvero dettagliato con charcode <-> stringa}

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

Circa 70 solo per il corpo del metodo.

Aggiungi 5 caratteri per includere un LF / CR nell'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));}}

Una versione LINQ sarebbe più breve:

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) .. tranne che richiede using System.Linq;(totale: 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.