Contando y deletreando

26

Escriba un programa que tome como entrada una cadena que genere una cadena con las siguientes propiedades.

  • Si un carácter en la cadena es una letra mayúscula (ASCII 41-5A), entonces el carácter se reemplaza por una cadena que contiene cada letra hasta e incluyendo la letra original en mayúscula. Por ejemplo, si la cadena de entrada es I, entonces la salida sería ABCDEFGHI.
  • Del mismo modo, si un carácter es una letra minúscula (ASCII 61-7A), el carácter se reemplaza de la misma manera. isería sustituido por abcdefghi.
  • Si un carácter es un número (ASCII 30-39), entonces el carácter se reemplaza por cada número comenzando 0y contando hasta el número.
  • Si la entrada contiene caracteres individuales concatenados, las secuencias de reemplazo se concatenan juntas.
  • Todos los demás caracteres se imprimen sin modificación.

Entradas de muestra (separadas por líneas en blanco)

AbC123

pi=3.14159

Hello, World!

Resultados de muestra

AabABC010120123

abcdefghijklmnopabcdefghi=0123.0101234010123450123456789

ABCDEFGHabcdeabcdefghijklabcdefghijklabcdefghijklmno, ABCDEFGHIJKLMNOPQRSTUVWabcdefghijklmnoabcdefghijklmnopqrabcdefghijklabcd!

Este es el código de golf, amigos. Aplican reglas estándar. El código más corto en bytes gana.

Para ver la tabla de clasificación, haga clic en "Mostrar fragmento de código", desplácese hasta la parte inferior y haga clic en "► Ejecutar fragmento de código". Fragmento hecho por Optimizer.

Mostrar fragmento de código

code-golf string Arcturus
fuente
10
Idea para una secuela: deshacer esta transformación.
ETHproductions
2
@ETHproductions Quizás, aunque la forma aquí me parece mejor porque puede tomar cualquier entrada; ¿y si en el reverso la entrada fuera Hello, World!?
Arcturus
¿Tenemos que admitir caracteres NUL (ascii 0x00) en la cadena de entrada?
nimi
@Eridan en tal caso, el código debe imprimir un error o, para darle un giro divertido, realizar la transformación anterior. Es decir, f (f (entrada)) == entrada. No creo que sea posible que cualquier entrada alfanumérica desobedezca esta relación.
Jake
1
Eso es completamente cierto: supongo que "si una cadena PUEDE SER el resultado de la transformación, inviértala. De lo contrario, aplique la transformación". - es su desafío, puede especificar las reglas que elija siempre y cuando (a) sean consistentes y (b) sean verificables y no requieran una nueva rama matemática completa para resolver. Nota al margen: Irradicar (b) sería interesante; nunca se sabe cuándo alguien revolucionará accidentalmente la informática presentando un algoritmo de tiempo polinómico para un problema de NP, que en realidad es razonable aquí, siempre que ahorre 4 bytes.
Jake

Respuestas:

11

Pyth, 19 bytes

sXzsJ+rBG1jkUTs._MJ

Pruébelo en línea: Demostración o conjunto de pruebas

Explicación

sXzsJ+rBG1jkUTs._MJ
      rBG1            the list ["abc...xyz", "ABC...XYZ"]
     +    jkUT        appends the string "0123456789"
    J                 save this list of 3 strings in J
   sJ                 join the strings in J
               ._MJ   create all prefixes of the strings in J
              s       and combine them to one list
 XzsJ         s._MJ   translate the input string, chars from sJ
                      get translated to the correct prefix,
                      chars that don't appear in sJ don't get translated
s                     join all resulting translation strings
Jakube
fuente
8

Python 2.7, 100 98 96 bytes

a=[]
for c in raw_input():d=ord(c);a+=range(max(d&96|1,48),d)*c.isalnum()+[d]
print bytearray(a)
xsot
fuente
7

TeaScript , 24 bytes 26 28

TeaScript es JavaScript para jugar al golf

xl(#(i=lN()1)h(ii(l)+1))

Muy corto

Pruébalo en línea

Explicación

x.l(#            // Loops through each character of the string

     (i=l.N()1)  // Determines whether a character is alphanumeric
                 // Will return A-Z, a-z or 0-9 depending on result
                 // Assigns to variable i

     .h(         // Get characters up to...
        i.i      // where the character is in "i"
     ) + 1       // Increased by one
)
Downgoat
fuente
6

Rubí, 137 87 82 76 67 55 bytes

Ungolfed, pero puedes ver el patrón.

$><<gets.gsub(/[a-z0-9]/i){[*" 0Aa"[$&.ord/32]..$&]*""}

Editar: golfed a solo una expresión regular.

Edición 2: tenía muchos espacios extra.

Edición 3: ¡Gracias a manatwork por jugar al golf en 12 bytes!

Peter Lenkefi
fuente
1
$><<gets.gsub(/[a-z0-9]/i){[*" 0Aa"[$&.ord/32]..$&]*""}
manatwork
@manatwork ¡Maldición, eso es inteligente!
Peter Lenkefi
4

Python 2, 145 140 133 103 102 Bytes

Una función anónima no tan elegante que utiliza la comprensión de listas. Siento que la lógica debería ser mucho más corta, intentaré resolver algo.

lambda k:''.join([c,`map(chr,range(48+17*(c>'@')+32*(c>'`'),ord(c)+1))`[2::5]][c.isalnum()]for c in k)

Se le debe dar un nombre para ser utilizado, es decir f=...

Kade
fuente
@Mego Oh, jaja! No te preocupes :)
Kade
4

Haskell, 95 91 86 60 bytes

c#(a:o:r)|c<a||c>o=c#r|1<2=[a..c]
c#_=[c]
f=((#"AZaz09")=<<)

Ejemplo de uso: f "pi=3.14159"->"abcdefghijklmnopabcdefghi=0123.0101234010123450123456789"

Cómo funciona: copie todos los caracteres en la cadena de entrada a menos que c esté en el medio de A/ Z, a/ zo 0/ 9y, de ser así, tome la lista de [<first char in pair> ... <c>].

Editar: @Zgarb guardó muchos bytes. ¡Gracias!

nimi
fuente
Creo que puedes definir c#_=[c]y omitir por tcompleto.
Zgarb
@ Zgarb: Sí, de hecho, y stambién es superfluo. ¡Muchas gracias!
nimi
4

JavaScript (ES6), 143 138 bytes

Utiliza comparaciones de cadenas para probar qué caracteres usar.

s=>s.replace(/[A-Z0-9]/gi,c=>(a=btoa`Ó]·ã»óÖq×£Y§¢«²Û¯Ã³`,(c>'Z'?a:a.toUpperCase()).split``.filter(x=>x<=c&(x>'9'|c<'A')).join``))

Demo en línea. Probado en Firefox y Chrome.

Editar: guardado 5 bytes reemplazando a='0123456789abcdefghijklmnopqrstuvwxyz'con

a=btoa`Ó]·ã»óÖq×£Y§¢«²Û¯Ã³`
codificador intrépido
fuente
3

PHP, 146 bytes

Golfed 

function f($n,&$l){for(;$c=$n[$r],$b=0,$d=ord($c);$r++,$b?:$l.=$c)foreach([58=>48,91=>65,123=>97] as $m=>$i)while($d<$m&&$d>=$i)$b=$l.=chr($i++);}

Revisión 1: poner rangos ord directamente en foreach. incrementó el rango ord máximo y cambió $d<=$ma $d<$m. usando forpara iterar caracteres en lugar de foreachy str_split. Eliminado todo {}moviendo el código afor

Sin golf 

function f($input,&$output){
foreach (str_split($input) as $char){
  $ord = ord($char);
  $ords = [57=>48,90=>65,122=>97];
  $b = 0;
  foreach ($ords as $max=>$min){
     while ($ord<=$max&&$ord>=$min){
         $b = $max;
         $output .= chr($min);
         $min++;
     }
  }
  $b ?: $output.=$char;
}
};

$output = NULL;
$input = "pi=3.141592";
f($input,$output);
echo $output;

Explicación: dividir la cadena en una matriz. Si el valor ascii cae en un rango (para az, AZ, 0-9), incremente un contador desde el mínimo del rango hasta el valor ascii del personaje, agregando cada valor hasta llegar al valor ascii del personaje.

Pasé por &$varlo que la salida se hace por referencia en lugar de unreturn

Caña
fuente
No es necesario que la variable $ z contenga la matriz de rangos, puede colocar la matriz literal directamente foreach.
manatwork
¿Intentaste usar range()? pastebin.com/k2tqFEgD
manatwork
@manatwork, cambié de declarar $ze hice algunos otros cambios. range()probablemente sería mejor Podría intentar algo con rango más tarde.
Reed
Usando range, obtuve function f($n,&$l){$o=['a'=>'z','A'=>'Z','0'=>'9'];foreach(str_split($n) as $c){$b=0;foreach($o as $m=>$x)!($c>$m&&$c<=$x)?:$b=$l.=implode(range($m,$c));$b?:$l.=$c;}}, que era 166.
Reed
1
Sí, después de reescribir a 146 caracteres usando range()es menos beneficioso. Pero ese 166 es demasiado largo aún: el $ o para el literal de matriz está de vuelta, hay espacios adicionales alrededor de las aspalabras clave, join()es un alias para implode(). (?. Comprobado el código de Pastebin he vinculado anteriormente muestra otra posibilidad de almacenar los puntos finales de rango) En cuanto a su solución de 146 caracteres, se puede mover la asignación de $ c dentro de la ord()llamada: $d=ord($c=$n[$r]).
manatwork
2

Python, 143 bytes

lambda s:''.join(map(chr,sum(map(lambda a,r=range:r(65,a+1)if 64<a<97else r(97,a+1)if 96<a<123else r(48,a+1)if 47<a<58else[a],map(ord,s)),[])))

Pruébalo en línea

Mego
fuente
2
Puede usar z = range para guardar 4 bytes.
Arcturus
1
Bastante seguro de que puede reemplazar los guiones de doble ambiente con una sola pestaña, lo que le ahorraría unos pocos bytes
Demanda del Fondo Monica
2

Perl 6, 101 bytes

Aquí hay un primer paso:

sub MAIN($_ is copy){
  s:g/<[0..9]>/{(0..$/).join}/;
  s:g/<[a..z]>/{('a'..~$/).join}/;
  s:g/<[A..Z]>/{('A'..~$/).join}/;
  .say
}
sub MAIN($_ is copy){s:g/<[0..9]>/{(0..$/).join}/;s:g/<[a..z]>/{('a'..~$/).join}/;s:g/<[A..Z]>/{('A'..~$/).join}/;.say}

119

Utilizando .transel $_de eliminar is copy.

sub MAIN($_){
  .trans(
    /\d/       => {(0..$/).join},
    /<[a..z]>/ => {('a'..~$/).join},
    /<[A..Z]>/ => {('A'..~$/).join}
  ).say
}
sub MAIN($_){.trans(/\d/=>{(0..$/).join},/<[a..z]>/=>{('a'..~$/).join},/<[A..Z]>/=>{('A'..~$/).join}).say}

106

Actúa @*ARGSdirectamente en lugar de definir un MAINsub.
(de lo contrario, idéntico al ejemplo anterior)

@*ARGS[0].trans(/\d/=>{(0..$/).join},/<[a..z]>/=>{('a'..~$/).join},/<[A..Z]>/=>{('A'..~$/).join}).say

101

Brad Gilbert b2gills
fuente
2

Scala, 111 91 bytes

val f=(_:String).flatMap(x=>if(x.isDigit)('0'to x)else if(x.isUpper)('A'to x)else('a'to x))
Martin Seeler
fuente
Esto falla por pi=3.14159. ¿Podría ser la solución val f=(_:String).flatMap(x:String=>if(x.isDigit)('0'to x)else if(x.isUpper)('A'to x)else if(x.isLower)('a'to x)else x.toString)para la friolera de 128 caracteres?
Leonardo
2

Julia, 102 98 90 84 bytes

s->join([(i=Int(c);join(map(Char,(64<c<91?65:96<c<123?97:47<c<58?48:i):i)))for c=s])

Esto crea una función sin nombre que acepta una cadena y devuelve una cadena.

Sin golf:

function f(s::AbstractString)
    # For each character in the input, get the codepoint and construct
    # a range of codepoints from the appropriate starting character to
    # the current character, convert these to characters, and join them
    # into a string
    x = [(i = Int(c);
          join(map(Char, (isupper(c) ? 65 :
                          islower(c) ? 97 :
                          isdigit(c) ? 48 : i):i))
         ) for c in s]

    # Join the array of strings into a single string
    return join(x)
end
Alex A.
fuente
2

PowerShell, 155 bytes

($args-split''|%{$b=$_;switch([int][char]$_){{$_-in(65..90)}{[char[]](65..$_)}{$_-in(97..122)}{[char[]](97..$_)}{$_-in(48..57)}{0..$b}default{$b}}})-join''

Técnicamente una línea, y PowerShell se trata de eso ;-)

Divide la entrada, canaliza eso en un ForEach-Objectbucle, activa el valor entero del personaje de lanzamiento, luego genera nuevos char[]rangos apropiados. Tenga en cuenta que tenemos que gastar bytes para establecer una variable temporal $bporque el acto de emitir la entrada $_en la declaración del interruptor significa que no podemos seguir usando $_o obtendremos resultados extravagantes.

EDITAR: debo señalar que esto eliminará los errores ya que el primer objeto que se alimenta %{...}es un objeto nulo. Dado que STDERR se ignora por defecto , esto no debería ser un problema. Si es un problema, cambie el primer bit ($args-split''-ne''|...para eliminar el objeto nulo.

AdmBorkBork
fuente
2

JavaScript (ES6), 340 258 273 271 bytes

a=s=>{s=s.split``;Q=x=>x.toUpperCase();A="ABCDEFGHIJKLMNOPQRSTUVWXYZ";D="0123456789";f="";for(i=0;i<s.length;i++){j=s[i];c="to"+(Q(j)==j?"Upper":"Lower")+"Case";j=Q(j);if(q=A.search(j)+1)f+=g=A.slice(0,q)[c]();else if(q=D.search(j)+1)f+=g=D.slice(0,q);else f+=j}return f}
Conor O'Brien
fuente
Puede usar una cadena de plantilla `` para dividir en lugar de ("")y f=i=""en el bucle for. Es posible que pueda guardar algunos bytes más.
intrepidcoder
@intrepidcoder El primero funcionaría. Estoy revisando el segundo.
Conor O'Brien
2

C (269 bytes)

(salto de línea agregado para mayor claridad)

#include<stdio.h>
#define F(x,y,z)if(c>=T[0][x]&&c<=T[1][y]){z}
#define L(x,y)for(i=0;i<x;++i){y}
main(){int c,i,n;char o,*T[]={"0Aa","9Zz"};while((c=getchar())!=EOF)
{F(0,2,L(3,F(i,i,o=T[0][i],n=++c-o;L(n,putchar(o++));break;))else putchar(c);)}}

Sin golf

#include<stdio.h>
int main(void)
{
  int c, i, n;
  char output;
  char *char_table[] = {"0Aa", "9Zz"};

  while ((c = getchar()) != EOF) {
    if (c < '0' || c > 'z') {
      putchar(c);
    } else {
      for (i = 0; i < 3; ++i) {
        if (c >= char_table[0][i] && c <= char_table[1][i]) {
          output = char_table[0][1];
          n = c - output;
          break;
        }
      }
      for (i = 0; i <= n; ++i) {
        putchar(output);
        ++output;
      }
    }
  }
  return(0);
}
musaritmia
fuente
2

Perl 5 , 66 61 (51 Bytes + 1) 52

La combinación de expresiones regulares con operadores condicionales funcionó bien en este caso.
Con una unión Uso del mapa para combinar los rangos en una matriz.

say map{(/\d/?0:/[A-Z]/?A:/[a-z]/?a:$_)..$_}split//

Prueba

$ echo "A0C1.a3c_2!" |perl -M5.010 -n count_and_spell_up.pl
A0ABC01.a0123abc_012!

Explicación

say                # print output
  map{             # loop through the array that's at the end of the other mustache. 
                   # outputs an array. 
     (
        /\d/?0            # if $_ is a digit then 0
          :/[A-Z]/?A      # else, if it's an uppercase character then A
             :/[a-z]/?a   # else, if it's a lowercase character then a
               :$_        # else the current character
     )..$_         # generate a sequenced string of characters 
                   # that ends with the magic variable $_ 
                   # ($_ is currently a character from the array)
  }split//     # split the magic variable $_ (currently the input string)
               # to an array of characters
LukStorms
fuente
1

JavaScript (ES7), 125 bytes

Ya había dos respuestas JS centradas en la codificación de las cadenas, así que decidí optar por un enfoque más algorítmico utilizando String.fromCharCode():

x=>x.replace(/[^\W_]/g,z=>(c=z.charCodeAt(),f=c<65?48:c<97?65:97,String.fromCharCode(...[for(i of Array(c-f).keys())i+f])+z))

Una ventaja de usar este método es que requiere cualquier cantidad de códigos de caracteres, por joinlo que no es necesario ingresar la lista. Esto resultó más corto que cualquier otra técnica, así que estoy contento con el resultado.

ETHproducciones
fuente
1

MUMPS, 131 bytes

u(l,h) i l'>a,a'>h f j=l:1:a s o=o_$C(j),f=0
    q
t(s) f i=1:1:$L(s) s a=$A(s,i),f=1 d u(48,57),u(65,90),u(97,122) s:f o=o_$C(a)
    q o

Logré guardar unos pocos bytes aquí gracias al alcance dinámico de MUMPS . Aquí hay una versión sin golfing más o menos equivalente, que seguramente me encantaría resaltar sintaxis, si solo estuviera disponible el soporte para el módulo MUMPS Prettify .

convert(str) ;
    new asciiCode,flag,i,output
    for i=1:1:$LENGTH(str) do
    . set asciiCode=$ASCII(str,i)
    . set flag=1
    . do helper(48,57)
    . do helper(65,90)
    . do helper(97,122)
    . if 'flag do
    . . set output=output_$CHAR(asciiCode)
    quit
helper(low,high) ;
    if low'>asciiCode,asciiCode'>high do
    . for code=low:1:asciiCode do
    . . set output=output_$CHAR(code)
    . . set flag=0
    quit
senshin
fuente
1

Perl 6, 78 77 bytes

@*ARGS[0].trans(/\d/=>{[~] 0..$/},/<:L>/=>{[~] samecase("a",~$/)..~$/}).say
Teclas de acceso rápido
fuente
Yo sabía que podría acortarse mediante la combinación de las 'a'..'z'y 'A'..'Z'los casos, debería haber esforzado más.
Brad Gilbert b2gills 01 de
Recomiendo agregar <!-- language-all: lang-perl6 -->justo después ## Perl 6para que se resalte correctamente. (El cambio ya está pendiente en esta respuesta)
Brad Gilbert b2gills
Puede cambiar {[~](0..$/)}a {[~] 0..$/}cuál guardará un byte.
Brad Gilbert b2gills
0

Mathematica, 102 bytes

FromCharacterCode@Flatten[Which[64<#<91,65,96<#<123,97,47<#<58,48,1>0,#]~Range~#&/@ToCharacterCode@#]&

Oh bien...

LegionMammal978
fuente
0

CJam, 32 31 bytes

q_'[,_el^A,s+26/ff{_@#)<}:s\.e|

Pruébelo en línea en el intérprete de CJam .

Cómo funciona

q_    e# Push two copies of the user input.
'[,   e# Push the string of all ASCII characters up to Z.
_el   e# Push a copy and convert it to lowercase.
^     e# Perform symmetric difference this keeps only letters.
A,s+  e# Append the string "0123456789".
26/   e# Split the result into chunks of length 26.
ff{   e# For each character from input: For each chunk:
  _@  e#   Copy the chunk and rotate the character on top of it.
  #   e#   Push the index of the character in the string (-1 for not found).
  )<  e#   Increment and keep that many characters from the left of the chunk.
      e#   This pushes "" for index -1.
}
:s    e# Flatten the resulting arrays of strings.
      e# The results will be empty strings iff the character wan't alphanumeric.
\     e# Swap the result with the input string.
.e|   e# Perform vectorized logical OR.
Dennis
fuente
0

Python 2, 135 117 bytes

s=''
for c in raw_input():
 b=ord(c);e=b+1
 if c.isalnum():
  b=max(b&96,47)+1
 for i in range(b,e):s+=chr(i)
print s
TFeld
fuente
0

PHP - 291 bytes

Pasar la cuerda a GET["s"].

<?php $s=$_GET["s"];$m="array_map";echo implode($m(function($v){$i="in_array";$l="implode";$r="range";global$m;$a=ord($v);if($i($a,$r(48,57)))$v=$l($m("chr",$r(48,$a)));if($i($a,$r(65,90)))$v=$l($m("chr",$r(65,$a)));if($i($a,$r(97,122)))$v=$l($m("chr",$r(97,$a)));return$v;},str_split($s)));
indefinido
fuente
0

C #, 251 201 184 157 157 Bytes

using System;class c{static void Main(string[] i){foreach(var c in i[0])for(var x=c>64&c<91?'A':c>96&c<123?'a':c>47&c<58?'0':c;x<=c;)Console.Write(x++);}}

editar: Strike! Más corto que PowerShell;)

Stephan Schinkel
fuente
1
puedes hacer string[]i?
Erik the Outgolfer