Rimuovi gli spazi, mantenendo la capitalizzazione

27

Il tuo input sarà una frase, una frase o una parola inglese. Conterrà solo a-zA-Z' -,.!?. Il tuo compito è quello di prendere l'input, rimuovere gli spazi e quindi ridistribuire le maiuscole in modo tale che le lettere agli indici precedentemente maiuscole (e solo le lettere agli indici precedentemente maiuscole) siano maiuscole.

Ad esempio, se l'input è A Quick Brown Fox Jumped Over The Lazy Dog, gli indici (basati su 0) delle lettere maiuscole sono 0, 2, 8, 14, 18, 25, 30, 34, 39. Successivamente, rimuovere gli spazi dall'ingresso: AQuickBrownFoxJumpedOverTheLazyDog. Avanti, minuscolo tutte le lettere, ma maiuscolo quelli a 0, 2, 8, 14, 18, 25, 30, 34, 39: AqUickbrOwnfoxJumpEdovertHelazYdog, che è l'output.

Ingresso

Il tuo input sarà una frase, una frase o una parola inglese. Può contenere solo lettere minuscole, lettere maiuscole, trattini, apostrofi, virgole, punti, punti interrogativi, punti esclamativi e spazi.

Produzione

L'input con gli spazi rimossi, in minuscolo-d, con le lettere nell'indice delle maiuscole nell'input in maiuscolo-d.

NOTA: il programma non può arrestarsi in modo anomalo (errore che termina l'esecuzione) con IndexOutOfRange o errore simile.

Casi test

Hi! Test!
Hi!tEst!

A Quick Brown Fox Jumped Over The Lazy Dog
AqUickbrOwnfoxJumpEdovertHelazYdog

testing TESTing TeStING testing testing TESTING
testingtESTIngteStInGTEstingtestingtestiNG

TESTING... ... ... success! EUREKA???!!! maybe, don't, NOOOOO
TESTING.........success!eureKA???!!!maybe,don't,nooooo

Enter        PASSWORD ---------
Enterpassword---------

A a B b C c D d E e F f G g H h I i J j K k L l M m N n O o P p Q q R r S s T t U u V v W w X x Z z
AabbCcddEeffGghhIijjKkllMmnnOoppQqrrSsttUuvvWwxxZz

  TEST
teST
code-golf  string 
— Stefano
fonte
— Stephen,
"Ad esempio, se l'input è" Una volpe marrone rapida saltata sopra il cane pigro ", gli indici (in base 0) delle lettere maiuscole sono 0, 2, 8, 14, 18, 23, 27, 32" Sono "0, 2, 8, 14, 18, 25, 30, 34, 39
— Luke Sawczak,
@ LukeSawczak grazie, mio ​​cattivo
— Stephen,
Spazi di valutazione non consentiti, suppongo?
— Luis Mendo,
@LuisMendo il tuo presupposto è corretto. Questo è code-golf, giusto? : P
— Stephen,

Risposte:

7

Gelatina , 14 13 byte

nŒlTɓḲFŒlŒuṛ¦

Provalo online!

Come funziona

nŒlTɓḲFŒlŒuṛ¦  Main link. Argument: s (string)

 Œl            Convert s to lowercase.
n              Perform character-wise "not equal" comparison.
   T           Get the indices of all truthy elements, i.e., the indices of all
               uppercase letters in s. Let's call the resulting array J.
    ɓ          Begin a dyadic chain with left argument s and right argument J.
     ḲF        Split s at spaces and flatten, removing the spaces.
       Œl      Convert s to lowercase.
            ¦  Sparse application:
         Œu        Convert s to uppercase.
           ṛ       Take the resulting items of the uppercased string at all indices
                   in J, the items of the lowercased string at all others.
— Dennis
fonte
7

Python 2 , 114 byte

x=input()
X=x.replace(' ','')
print''.join([X[i].upper()if x[i].isupper()else X[i].lower()for i in range(len(X))])

Provalo online!

Equivalentemente:

Python 2 , 114 byte

lambda x:''.join([[str.lower,str.upper][x[i].isupper()](x.replace(' ','')[i])for i in range(len(x)-x.count(' '))])

Provalo online!

— HyperNeutrino
fonte
''.join([(X[i].lower,X[i].upper)[x[i].isupper()]()for i in range(len(X))])per -5 byte.
— Ovs,
5

Python 3 , 78 75 72 byte

s=input()
for c in s:s=s[c>' '!=print(end=(c+c).title()[s<'@'or'['<s]):]

Grazie a @xnor per giocare a golf con 6 byte!

Provalo online!

— Dennis
fonte
Puoi solo confrontare sinvece di s[0]?
— xnor
Sì, naturalmente. Grazie!
— Dennis,
1
(c*2).title()può darti entrambi i casi, anche se cambiato.
— xnor
Altri 3 byte. Grazie ancora!
— Dennis,
Difficile! Mi ci è voluto un po 'per capire che c>' '!=f()equivale a (c>' ') and (' '!=f()).
— Chas Brown,
5

05AB1E , 15 14 byte

-1 byte grazie a Emigna

ðKuvy¹Nè.lil}?

Provalo online!

ðK             # Remove spaces
  u            # Convert to uppercase
   vy          # For each character...
     ¹Nè       #   Get the character at the same index from the original input
        .lil}  #   If it was a lowercase letter change this one to lowercase
             ? # Print without a newline
— Riley
fonte
Si salva un byte se si mette in maiuscolo la stringa rimossa dallo spazio e in minuscolo nella condizione.
— Emigna,
5

Haskell , 98 95 89 88 81 byte

Grazie a @name, @nimi, @Zgarb e @Laikoni per aver contribuito a radere 14 byte in totale

import Data.Char
\s->zipWith(\p->last$toLower:[toUpper|isUpper p])s$filter(>' ')s

Ungolfed:

import Data.Char
\sentence -> zipWith (\oldChar newChar ->
                        if isUpper oldChar
                        then toUpper newChar
                        else toLower newChar)
                     sentence
                     (filter (/= ' ') sentence)
— Julian Wolf
fonte
Su dispositivo mobile, ma sembra che puoi salvare alcuni byte con filtro (/ = '')
— Henry,
Sì, certamente. Mancava la parte della specifica notando che gli spazi erano l'unico spazio bianco che doveva essere rimosso.
— Julian Wolf,
1
filter(>' ')per un byte in meno
— nimi
2
Penso che il corpo della lambda possa essere abbreviato inlast(toLower:[toUpper|isUpper p])c
— Zgarb
Commutazione gli argomenti di zipWithdeve salvare un altro byte: f s=zipWith(\p->last$toLower:[toUpper|isUpper p])s$filter(>' ')s.
— Laikoni,
4

V , 24 byte

ÄVuÓó
ejlDò/¥2lõ
vuk~òGd

Provalo online!

Questo tipo di sfide sono esattamente ciò per cui V è stata creata. :)

Spiegazione:

Ä           " Duplicate this line
 Vu         " Convert it to lowercase
   Óó       " Remove all spaces
e           " Move to the end of this line
 j          " Move down a line (to the original)
  l         " Move one char to the right
   D        " And delete the end of this line
    ò       " Recursively:
     /      "   Search for:
         õ  "     An uppercase character
      ¥2l   "     On line 2
            "     (This will break the loop when there are no uppercase characters left)
vu          "   Convert it to lowercase
  k         "   Move up a line
   ~        "   Convert this to uppercase also
    ò       " Endwhile
     G      " Move to the last line
      d     " And delete it
— DJMcMayhem
fonte
@DLosc Buone domande! Le newline segnalano la fine di un comando regex, come un comando sostitutivo (rimuovi) o di ricerca. Maggiori dettagli sono in questa pagina: github.com/DJMcMayhem/V/wiki/Regexes
— DJMcMayhem
4

Python 2, 100 byte

s=input()
print"".join([c.lower(),c.upper()][s[i].isupper()]for i,c in enumerate(s.replace(" ","")))
— erik
fonte
3
Benvenuti in PPCG e ottima prima risposta!
— ETHproductions
3

Alice , 32 byte

/..- ~l+u~mSloy
\ia''-y.'Qa.+a@/

Provalo online!

Spiegazione

Questo è un modello standard per programmi che funzionano interamente in modalità ordinale. Non imballato, il programma è il seguente:

i.' -l.uQm.lay.a-'~y+'~aS+o@

i       take input as string
.       duplicate
' -     remove spaces from copy
l.u     create all-lowercase and all-uppercase versions
Q       reverse stack, so original string is on top
m       truncate original string to length of spaces-removed string
.lay    convert everything except uppercase characters to \n
.a-'~y  convert everything except \n (i.e., convert uppercase characters) to ~
+       superimpose with lowercase string
        \n becomes the corresponding lowercase character, and ~ remains as is
'~aS    convert ~ to \n
+       superimpose with uppercase string
        lowercase in existing string stays as is because it has a higher code point
        \n becomes corresponding uppercase character
o       output
@       terminate
— Nitrodon
fonte
3

JavaScript (ES6), 94 91 85 byte

s=>s.replace(/./g,c=>c==" "?"":c[`to${"@"<s[x]&s[x++]<"["?"Upp":"Low"}erCase`](),x=0)
  • 6 byte salvati con l'assistenza di ETHproductions & Arnauld.

Provalo

o.innerText=(f=

s=>s.replace(/./g,c=>c==" "?"":c[`to${"@"<s[x]&s[x++]<"["?"Upp":"Low"}erCase`](),x=0)

)(i.value="Hi! Test!");oninput=_=>o.innerText=f(i.value)
<input id=i><pre id=o>
Espandi frammento

— ispido
fonte
— Stephen,
Potresti farlo '@'<s[i]&s[i]<'['??
— ETHproductions,
@StepHen: Aw, amico, non ho visto quella notte scorsa mentre stavo lavorando su questo.
— Shaggy,
@ETHproductions: mi chiedevo se potesse essere più breve, ma ero troppo pigro per cercare quali caratteri avrei dovuto usare: D Si scopre che salva un byte; Grazie.
— Shaggy,
3

Retina , 77 71 byte

.+
$&¶$&
T`L `l_`.+$
+`((.)*)[A-Z].*(¶(?<-2>.)*)
$1$3 
.+¶

T`l `L_` .?

Provalo online! Il link include la suite di test. Spiegazione: Il primo stadio duplica la linea mentre il secondo stadio mette in minuscolo il duplicato ed elimina i suoi spazi. Il terzo stadio quindi scorre attraverso ogni lettera maiuscola da destra a sinistra e tenta di posizionare uno spazio prima del carattere corrispondente sulla seconda riga. La prima riga viene eliminata e gli spazi vengono utilizzati per mettere in maiuscolo i caratteri rilevanti del risultato. Modifica: salvato 6 byte grazie a @Kobi.

— Neil
fonte
Piccola domanda: sono necessari (.?)e le $4parti? Sembra che avere un gruppo opzionale alla fine non faccia nulla.
— Kobi,
@Kobi Niente di piccolo in questa domanda! Inizialmente era stato parte di un tentativo di usare i lookaround per abbinare i personaggi da mettere in maiuscolo direttamente invece di doverli tradurre come un passaggio separato.
— Neil,
3

Perl, 95 94 + 1 = 95 byte

+1 byte di penalità per -n

Salva un byte sostituendo da s/\s//gas/ //g

$s=$_;s/ //g;$_=lc($_);while(/(.)/gs){$p=$&;$p=uc($p)if(substr($s,$-[0],1)=~/[A-Z]/);print$p;}

Provalo online!

Spiegazione:

  1. Crea una copia della stringa di input.

  2. Rimuovi tutti gli spazi e trasforma la stringa in minuscolo.

  3. Quindi avviare il ciclo su ogni lettera. Lettera di prova nella stessa posizione nella stringa salvata per maiuscole. Se superiore - rendere la lettera corrente catturata. Stampa lettera.

Si noti che perl deve essere eseguito con l'opzione della riga di comando "-n"

— Veitcel
fonte
Benvenuti in PPCG! Se lo desideri, puoi aggiungere un link a Provalo online: tio.run/# (lo aggiungerei, ma non so se questo è Perl 5 o Perl 6)
— Stephen
1
Penso che devi contare +1byte per la -nbandiera. A parte questo, sembra buono! Benvenuti nel sito! :)
— DJMcMayhem
@StepQuindi è Perl 5, potresti aggiungere link? Non sono riuscito a eseguire il mio codice lì in modo propper.
— Veitcel,
Felice di vedere un nuovo giocatore di golf Perl! Ho aggiunto il link TIO alla tua risposta e migliorato la formattazione.
— Dada,
2

Python 3 , 117 byte

s=input()
y=list(s.replace(' ','').lower())
i=0
for c in y:
 if s[i].isupper():y[i]=c.upper()
 i+=1
print(''.join(y))

Provalo online!

Questo è praticamente il mio primo codice golf, quindi è probabile che sia un male, meno l'aiuto dai commenti qui sotto!

PS Sì, è stupido che la definizione e l'incremento isalvino i byte nell'intervallo (len (y)). Oh bene.

— Luke Sawczak
fonte
1
Benvenuti in PPCG! Bella prima presentazione! Tuttavia, in conformità con gli standard I / O del nostro sito, l'invio deve essere una funzione di una stringa o accettare input; non puoi supporre che l'input sia in una variabile. Spero ti piaccia il tuo soggiorno! :)
— HyperNeutrino,
Grazie; modificato una funzione, ma anche salvato 5 byte nel corpo: D
— Luke Sawczak,
1
@LukeSawczak salva una tonnellata di byte cambiando in uno spazio per il rientro e forse aggiungi un Prova online! link se vuoi
— Stephen,
1
È possibile rimuovere lo spazio dopo return.
— Calcolatrice
@LukeSawczak come va? tio.run/…
— Stephen,
2

C # (.NET Core) , 108 101 byte

using System.Linq;s=>s.Replace(" ","").Select((c,i)=>s[i]>64&s[i]<91?char.ToUpper(c):char.ToLower(c))

Provalo online!

  • 7 byte salvati dopo aver realizzato che la charclasse ha statica ToUpper()e ToLower()metodi.
— Charlie
fonte
2

Carbone , 33 byte

Ａ⁰χＦＬθ¿⁼§θι Ａ⁺¹χχ¿№α§θ⁻ιχ↥§θι↧§θι

Provalo online!

Dato che non so ancora come passare una stringa con spazi bianchi come singolo parametro di input nel codice Charcoal, ho appena assegnato nell'intestazione la stringa di test alla variabile Charcoal che rappresenta quello che sarebbe il primo input ( θ):

ＡA Quick Brown Fox Jumped Over The Lazy Dogθ

Quindi il codice ha lo stesso numero di byte come se la stringa fosse passata come primo input.

Puoi vedere qui la versione dettagliata del codice.

— Charlie
fonte
1
Ho detto in un'altra risposta, ma nel caso in cui lo dimentichi, inserisci semplicemente come un array Python con un elemento
— ASCII-only
Ho solo bisogno che l'input abbia una nuova riga finale.
— Neil,
2

PHP, 181 byte

Provo a ottenere il minor numero di byte, questo è il mio codice:

<?php
$s=readline();
preg_match_all('/[A-Z]/',$s,$m,PREG_OFFSET_CAPTURE);
$s=strtolower(str_replace(' ','',$s));
while($d=each($m[0]))$s[$d[1][1]]=strtoupper($s[$d[1][1]]);
echo $s;

Provalo online!

— kip
fonte
Invece di una costante PREG_OFFSET_CAPTUREè possibile utilizzare il valore 256, $argnè una variabile più breve come readline()per un input e penso ctype_uppere uso di lcfirste ucfirstsalverò molti byte con un ciclo e l'uso di $$ie operatore ternario
— Jörg Hülsermann
2

Java 8, 184 177 161 byte

s->{String r="";for(int i=0,j=i,t,u;i<s.length;){t=s[i++];if(t>32){u=s[j++];r+=(char)(t<65|t>90&t<97|t>122?t:u>64&u<91?t&~32:u>96&u<123|u<33?t|32:t);}}return r;}

Può sicuramente giocare a golf ancora un po '..
- 16 byte grazie a @ OlivierGrégoire prendendo l'input come char[]invece di String.

Spiegazione:

Provalo qui.

s->{                           // Method with char-array parameter and String return-type
  String r="";                 //  Result-String
  for(int i=0,j=i,t,u;         //  Some temp integers and indices
      i<s.length;){            //  Loop over the String
    t=s[i++];                  //   Take the next character and save it in `t` (as integer)
                               //   and raise index `i` by 1
    if(t>32){                  //   If `t` is not a space:
     u=s[j++];                 //   Take `u` and raise index `j` by 1
     r+=                       //   Append the result-String with:
      (char)                   //    Integer to char conversion of:
       (t<65|t>90&t<97|t>122?  //     If `t` is not a letter:
        t                      //      Simply use `t` as is
       :u>64&u<91?             //     Else if `u` is uppercase:
        t&~32                  //      Take `t` as uppercase
       :u>96&u<123|u<33?       //     Else if `u` is lowercase or a space:
        t|32                   //      Take `t` as lowercase
       :                       //     Else:
        t);                    //      Take `t` as is
    }
  }                            //  End of loop
  return r;                    //  Return result-String
}                              // End of method
— Kevin Cruijssen
fonte
1
Prendi una char[]stringa anziché una stringa per questo, risparmierai molti byte!
— Olivier Grégoire,
D'altra parte, ho risposto anche con un altro algoritmo. E qui, prendo gli argomenti opposti: in = String, out = char[]:-)
— Olivier Grégoire
2

Lisp comune, 104 byte

(defun f(s)(map'string(lambda(x y)(if(upper-case-p x)(char-upcase y)(char-downcase y)))s(remove #\  s)))

Provalo online!

Insolitamente abbreviazione del prolisso Common Lisp!

Codice semplice:

(defun f (s)                     ; receive the string as parameter
  (map 'string                   ; map the following function of two arguments
       (lambda (x y)             ; x from the original string, y from the string with removed spaces
         (if (upper-case-p x)    ; if x is uppercase
             (char-upcase y)     ; get y uppercase
             (char-downcase y))) ; else get y lowercase
       s
       (remove #\  s)))
— Renzo
fonte
2

Java (OpenJDK 8) , 150 117 113 97 byte

s->{for(int i=0,j=0,c;i<s.length;)if((c=s[i++]&95)>0)System.out.printf("%c",c^(s[j++]|~c/2)&32);}

Provalo online!

Mentre giocavo a golf di più, sono arrivato a 102 byte:

s->{for(int i=0,j=0,c;i<s.length;)if((c=s[i++]&95)>0)System.out.printf("%c",c<64?c|32:c|s[j]&32,j++);}

Provalo online!

Ma mi sono ricordato che stava iniziando ad assomigliare alla risposta di Dennis, quindi ho semplicemente portato il suo accarezzare e ... la magia è accaduta. Il grande guadagno dal porto è rimuovere i rami e le ripetizioni al loro interno.

— Olivier Grégoire
fonte
@ceilingcat che non funziona: Hi! Test!dovrebbe diventare Hi!tEst!, ma con la tua soluzione diventa Hi!Test.
— Olivier Grégoire il
2

Fogli Google, 213 byte

=ArrayFormula(JOIN("",IF(REGEXMATCH(MID(A1,ROW(OFFSET(A1,0,0,LEN(A1))),1),"[A-Z]"),MID(UPPER(SUBSTITUTE(A1," ","")),ROW(OFFSET(A1,0,0,LEN(A1))),1),MID(LOWER(SUBSTITUTE(A1," ","")),ROW(OFFSET(A1,0,0,LEN(A1))),1))))

L'input è nella cella A1e la formula si suddivide in questo modo:

  • ArrayFormula()ci consente di valutare ogni termine in modo ROW()indipendente
  • JOIN() concatena tutti quei risultati indipendenti in un'unica stringa
  • IF(REGEXMATCH(),UPPER(),LOWER() è ciò che lo fa alternare usando maiuscole o minuscole a seconda di quale caso si trovasse in quella posizione nell'input
  • ROW(OFFSET())restituisce una matrice di valori 1a A1.lengthche può essere immessa nella MID()funzione in modo da poter valutare ciascun carattere a turno

Risultati dei casi di test: (È più facile da leggere se si fa clic sulla versione più grande.)

Casi test

— Ingegnere Toast
fonte
2

Rubino , 80 byte

->a{n=a.downcase.delete' '
n.size.times{|i|(?A..?Z)===a[i]&&n[i]=n[i].upcase}
n}

Provalo online!

— alex
fonte
È possibile salvare un paio di byte utilizzando n.gsub(/./){}al posto di n.size.times{};n: n.gsub(/./){(?A..?Z)===a[i]?$&.upcase: $&}.
— Giordania,
2

Perl, 92 byte

$p[$i++]=$-[0]while s/[A-Z]/lc($&)/e;s/\s//g;for$c(@p){substr($_,$c,1)=~tr[a-z][A-Z]};print;

Spiegazione:

$p[$i++]=$-[0]while s/[A-Z]/lc($&)/e;   #get locations of caps into an array at the same time converting letters to lowercase

s/\s//g;   #delete all spaces

for$c(@p){substr($_,$c,1)=~tr[a-z][A-Z]};   #convert lowercase letters to uppercase where uppercase letters were present

print;   # print (of course) :)
— jmatix
fonte
1
Benvenuti in PPCG! :)
— Stephen,
Devi aggiungere -nflag per rendere valida la tua risposta. Alcune cose da golf: s/ //gè abbastanza (non è necessario \s), y/a-z/A-Z/è lo stesso di tr[a-z][A-Z], puoi usare -pflag in modo da non aver bisogno dell'ultimo print, non hai bisogno della parentesi lc$&.
— Dada,
1

C, 103 byte

i,j,c;f(char*s){for(i=j=0;c=tolower(s[j++]);)c-32&&putchar(c-32*(s[i]>64&&s[i]<91&&c>96&&c<123))&&++i;}

Provalo online!

— Steadybox
fonte
1

Python 2, 106 105 byte

s=input()
print''.join(map(lambda(c,u):[c.lower,c.upper][u](),zip(s.replace(' ',''),map(str.isupper,s))))

Modifica: salva un byte tramite print ''.join=> print''.join.

Modulo lambda, 99 byte

lambda s:''.join(map(lambda(c,u):[c.lower,c.upper][u](),zip(s.replace(' ',''),map(str.isupper,s))))
— Chas Brown
fonte
1

SCALA, 128 caratteri, 128 byte

var l=s.toLowerCase().filter(x=>x!=32)
for(i<-0 to l.size-1){if(s(i).isUpper)l=l.substring(0,i)+l(i).toUpper+l.substring(i+1)}
l

Grazie per questa sfida. Provalo online!

— V. Courtois
fonte
1

q / kdb +, 49 byte

Soluzione:

{@[a;(&)#:[a:lower x except" "]#x in .Q.A;upper]}

Esempi:

q){@[a;(&)#:[a:lower x except" "]#x in .Q.A;upper]}"Hi! Test!"
"Hi!tEst!"

q){@[a;(&)#:[a:lower x except" "]#x in .Q.A;upper]}"A Quick Brown Fox Jumped Over The Lazy Dog"
"AqUickbrOwnfoxJumpEdovertHelazYdog"

q){@[a;(&)#:[a:lower x except" "]#x in .Q.A;upper]}"testing TESTing TeStING testing testing TESTING"
"testingtESTIngteStInGTEstingtestingtestiNG"

q){@[a;(&)#:[a:lower x except" "]#x in .Q.A;upper]}"TESTING... ... ... success! EUREKA???!!! maybe, don't, NOOOOO"
"TESTING.........success!eureKA???!!!maybe,don't,nooooo"

q){@[a;(&)#:[a:lower x except" "]#x in .Q.A;upper]}"Enter        PASSWORD ---------"
"Enterpassword---------"

q){@[a;(&)(#:[a:lower x except" "]#x)in .Q.A;upper]}"A a B b C c D d E e F f G g H h I i J j K k L l M m N n O o P p Q q R r S s T t U u V v W w X x Z z"
"AabbCcddEeffGghhIijjKkllMmnnOoppQqrrSsttUuvvWwxxZz"

q){@[a;(&)#:[a:lower x except" "]#x in .Q.A;upper]}"  TEST"
"teST"

Spiegazione:

Trova gli indici in cui l'input è in maiuscolo e quindi applica la funzione uppera quegli indici in una versione minuscola e rimossa dallo spazio della stringa di input. Nota che non possiamo applicare la funzione oltre la lunghezza della stringa, quindi usa take ( #) per troncare la stringa di input alla lunghezza della versione minuscola, rimossa dallo spazio.

{@[a;where count[a:lower x except " "]#x in .Q.A;upper]} / ungolfed
{                                                      } / lambda function
 @[ ;                                           ;     ]  / apply FUNC to VAR at INDICES: @[VAR;INDICES;FUNC]
                                                 upper   / uppercase, upper["abc"] -> "ABC"
                                       x in .Q.A         / boolean list where input is in uppercase alphabet ABC..XYZ
                                      #                  / take this many elements from list on the right (ie truncate)
           count[                    ]                   / returns length of the stuff inside the brackets, count["ABC"] -> 3                                        
                         x except " "                    / remove " " from string
                   lower                                 / lowercase, lower["ABC"] -> "abc"
                 a:                                      / save in variable a
     where                                               / returns indices where true where[101b] -> 0 2
   a                                                     / our lowercased, space-stripped input

Bonus:

Dopo aver letto le risposte, ho pensato di provare una soluzione in cui ho ripetuto l'input, finora ho gestito solo una soluzione a 53 byte:

{a{$[y in .Q.A;upper x;x]}'#:[a:lower x except" "]#x}
— streetster
fonte
1

Swift 3.0, 199 byte

var s="AS Ff",i=[String](),p=[Int](),j=0;for c in s.characters{if c>="A"&&c<="Z"{p.append(j)};if c != " "{i.append(String(c).lowercased())};j=j+1};for c in p{i[c]=i[c].uppercased()};print(i.joined())

Provalo online!

— A. Pooja
fonte
1

Perl 5 , 40 byte

37 byte di codice + -Fflag. (nota che nelle vecchie versioni di Perl, potresti dover aggiungere -anflag)

print$F[$i++]=~/[A-Z]/?uc:lc for/\S/g

Provalo online!

Spiegazioni:
Grazie a -F, @Fcontiene un elenco di tutti i caratteri dell'input.
for/\S/gscorre ogni carattere non spaziale dell'input. Usiamo $ia contare in cui l'iterazione siamo. Se $F[$i++]è un carattere maiuscolo ( /[A-Z]/), quindi stampiamo il carattere corrente maiuscolo ( uc), altrimenti lo stampiamo in minuscolo ( lc). Nota che uce lcrestituisci il loro argomento invariato se non è una lettera.

Versione precedente (meno giocata a golf: 47 byte): 

 s/ //g;s%.%$_=$&;$F[$i++]=~/[A-Z]/?uc:lc%ge

Provalo online!

— Dada
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.