Gere uma cifra

15

Gere uma cifra com um número e uma string

Sua tarefa é simples. Dada uma sequência se um número 0 <= n <= 9como entradas, insira um caractere ASCII imprimível pseudo-aleatório entre cada caractere dos ntempos da sequência . De modo que, para cada personagem, shaja ncaracteres aleatórios entre eles. Os espaços devem ser aparados.

Entrada:

  • sfrase de cadeia para criptografar na cifra
  • inteiro nna faixa de0 <= n <= 9

Exemplo:

Entrada:

The treasure is here
2

Resultado:

T ! 0 h 32 e F4 t 0i r lk e hm a 7y s # 0 u * & r * h e ! 2 i H ^ s B, h ! @ E 0) r $ h e


Isso é então o código mais curto vence! Boa sorte e divirta-se!

jacksonecac
fonte
3
caractere ASCII imprimível aleatório Você precisa definir o que significa aleatório aqui. Todos os caracteres ASCII imprimíveis têm a mesma probabilidade? Eles devem ser estatisticamente independentes? Que flexibilidade temos em relação a isso?
Luis Mendo
3
@jacksonecac Eu discordo. Apenas dizer aleatório não é suficiente. Por exemplo, se eu escolher apenas caracteres aleatórios com códigos ASCII mesmo, isso ainda é aleatório, mas provavelmente não é aceito (ou não é?) Se cada série de ncaracteres consistir em ncópias do mesmo caractere aleatório, elas ainda serão aleatórias, mas serão não é estatisticamente independente. E assim por diante
Luis Mendo 22/11
5
@jacksonecac "random" é um termo muito amplo. Posso escolher os caracteres com uma distribuição normal, para que os caracteres ao redor Osejam mais prováveis ​​que os espaços ou ~? Se tiver que ser uniforme, você deve dizê-lo explicitamente. E se não precisa ser uniforme, você deve pelo menos declarar que algo como cada caractere precisa ter uma probabilidade diferente de zero. Você também já declarou em um comentário anterior que cada personagem não tem que ter uma distribuição independente, por isso, se isso é importante, deve ser mencionado no desafio. Existe um espectro muito amplo de aleatoriedade.
Martin Ender
3
Isso não é realmente uma cifra. É esteganográfico, talvez.
22816 Greg Martin
2
Essa não é uma resposta apropriada ao ponto válido de @MartinEnder. Uma solução seria especificar explicitamente que os caracteres devem ser uniformes e estatisticamente independentes um do outro e os comentários serão interrompidos. Uma especificação alternativa (mas mais aberta a abusos) seria que as distribuições distorcidas ou aquelas em que os caracteres dependem um do outro estejam OK, desde que todos os caracteres tenham uma possibilidade diferente de zero. No código, a especificação do golfe é importante para a justiça. Como você parece relutante em abordar esses comentários válidos em um bom desafio, estou votando para encerrar.
Level River St

Respostas:

7

C #, 141 131 bytes

Muito parecido com a resposta Java da @ Geobit , mas atualmente há mais tempo :(

(I,n)=>{var R=new System.Random();var o="";int i,r;foreach(var c in I)if(c>32)for(i=r=0,o+=c;i++<n;){r=R.Next(33,127);o+=(char)r;}return o;};

Material lambda completo:

Func<string, int, string> a = (I,n) =>
{
    var R=new System.Random();
    var o="";
    int i;
    foreach(var c in I)
        if(c>32)
            for(i=0,o+=c;i++<n;o+=(char)R.Next(33,127));
    return o;
};
Yodle
fonte
porque R=...você pode apenas usar diretamente new System.Random().Next(...)eu acho
Roman Gräf
2
@ RomanGräf msdn.microsoft.com/en-us/library/h343ddh9(v=vs.110).aspx A classe aleatória do C #, sem uma semente, usará o relógio do sistema, portanto, se você chamar em rápida sucessão (como dentro do loop de lá), a maioria dos valores acabam sendo idênticos, o que não iria funcionar na maioria dos casos :( Acredite em mim, eu sempre tentar e, em seguida, lembre-se disso.
Yodle
7

05AB1E , 11 bytes

ð-vy²FžQ.RJ

Experimente online!

Explicação

ð-           # remove spaces from input string
  v          # for each char in the string
   y         # push the char
    ²F       # input-2 number of times do:
      žQ.R   # push a random ascii character
          J  # join to string
Emigna
fonte
fechar! aparar os espaços! :)
jacksonecac
@jacksonecac: Perdi essa parte, desculpe. Corrigido agora :)
Emigna 22/11
bom trabalho! isso funciona!
jacksonecac
1
@carusocomputing: que adiciona caracteres aleatórios após a última letra também. Não apenas entre as letras.
Emigna
1
@Emigna Depois de um comentário recente sob a questão parece ser bem :)
geisterfurz007
6

Java 7, 132 124 bytes

String f(int n,char[]a){String o="";int i;for(char b:a)if(b>32)for(i=0,o+=b;i++<n;o+=(char)(33+Math.random()*94));return o;}

Nada extravagante, apenas um loop duplo como você esperaria. Externo para fazer um loop na cadeia, interno para preencher randoms:

String f(int n,char[]a){
    String o="";
    int i;
    for(char b:a)
        if(b>32)
            for(i=0,
                o+=b;
                    i++<n;
                        o+=(char)(33+Math.random()*94));
    return o;
}
Geobits
fonte
Não há necessidade de k: String f(int n,char[]a){String o="";for(char b:a)if(b>32){o+=b;for(int i=0;i++<n;o+=(char)(33+Math.random()*94));}return o;}(125 bytes)
Olivier Grégoire
Oooh certo. Eu estava usando com um método diferente. Não pensei em tirá-lo quando fui com o charelenco. Obrigado!
Geobits
Foi mal. Eu desconectei, minha sugestão também era de 124 bytes: verifiquei a coluna em vez do comprimento;)
Olivier Grégoire
Sim, eu notei que quando se comparam os dois :)
Geobits
5

Pyke, 12 11 9 bytes

d-FQV~KHs

Experimente aqui!

d-        -  remove spaces from input
  F       - for i in ^:
   QV     -  repeat (number) times:
     ~KH  -    random_from(printable)
        s -   sum(^)

Trailing caracteres aleatórios é bom de acordo com OP.

Azul
fonte
5

Oitava, 43 bytes

@(s,n)[s(s>32);33+94*rand(n,nnz(s>32))](:)'

Isso leva uma string se um número inteiro ncomo entrada. Uma string no Octave é simplesmente uma matriz de caracteres. s>32é um mapa lógico 1para quaisquer caracteres não espaciais. O código anexa uma matriz com nlinhas e o mesmo número de colunas que s(s>32)possui, contendo números de ponto flutuante entre 33 e 126. É implicitamente arredondado para números inteiros e convertido em caracteres ASCII quando concatenado com a string s. (:)'endireita isso para uma matriz horizontal de caracteres.

Teste aqui!

Stewie Griffin
fonte
1
Arredondamento implícito! Agradável
Luis Mendo
4

Python 2, 123 122 118 114 98 Bytes

Cara, eu gostaria que randomnão fosse tão caro (e que não precisássemos filtrar por espaços). Agora temos uma grande economia de podermos ter caracteres cifrados no final :) De qualquer forma, aqui está:

from random import*
f=lambda s,n:s and(' '<s[0])*eval('s[0]'+'+chr(randint(32,126))'*n)+f(s[1:],n)
Kade
fonte
4

JavaScript (Firefox 30+), 96 bytes

(s,n)=>s.replace(/. */g,x=>x[0]+String.fromCharCode(...[for(_ of Array(n))Math.random()*95+32]))

O ES6 puro tem dois bytes a mais:

(s,n)=>s.replace(/. */g,x=>x[0]+String.fromCharCode(...[...Array(n)].map(_=>Math.random()*95+32)))

Aqui está uma abordagem muito interessante que, infelizmente, é 26 bytes mais longa:

(s,n)=>String.raw({raw:s.split` `.join``},...[for(_ of s)String.fromCharCode(...[for(_ of Array(n))Math.random()*95+32])])
ETHproductions
fonte
Estritamente falando /. *(?=.)/, não funciona para strings que começam ou terminam em espaços, não que alguém se importe. (Você está ainda permitiu arrastando caracteres aleatórios agora.)
Neil
@ Neil Trailing caracteres aleatórios são permitidos? Eu acho que posso apenas remover o (?=.)que cuida de espaços no final das strings.
ETHproductions
A especificação não é tão clara, mas acho que você shold evitar a inserção de espaços em branco, então 94+33em vez de95+32
edc65
3

R, 97 bytes

Função sem nome, recebendo entradas x(string) e n.

function(x,n,l=nchar(x))for(i in 1:l)cat(substr(x,i,i),if(i<l)intToUtf8(sample(32:126,n)),sep="")

Experimente no R-fiddle

Billywob
fonte
3

CJam , 21 18 bytes

lS-(ol~f{{95mrSc+\}*}

Experimente online!

Imprime ncaracteres finais aleatórios.

Explicação

lS-        e# Read line and remove spaces.
l~         e# Read and evaluate another line.
f{         e# For each character (passing in N)...
  {        e#   Do this N times...
    95mr   e#     Push random integer in [0, 95).
    Sc+    e#     Add to space character, giving a random printable ASCII character.
  }*
}
           e# All characters remaining on the stack are printed implicitly
           e# at the end of the program.
Martin Ender
fonte
3

Bash, 124 bytes

Pure bash + coreutils , sem estruturas de controle de fluxo, sem sub-idiomas, sem "eval"

Golfe

E() { N=${1// /};paste <(fold -1<<<$N) <(tr -cd "\\40-\\176"<\/dev\/urandom|head -c$(($2*${#N}-$2))|fold -$2)|tr -d '\t\n';}

Teste

>E "The treasure is here" 2
TkZhf(e&Rt@FrS,edha+-sJTuh.rX@eVKi+3s<7hftey8r*/e
zepelim
fonte
3

Q / KDB +, 39 36 34 bytes

raze{""sv(raze x;`char$40+n?87)}prior s
(,/)({""sv((,/)x;`char$40+n?87)}':)s

(,/)({""sv((,/)x;10h$40+n?87)}':)s

Variáveis ​​em uso:

s:"The treasure is here"
n:2

Isso usa o anterior advérbio , que aplica a função à esquerda entre cada item à direita e seu antecessor. (Essencialmente, aplica função à esquerda entre cada caractere à direita.)

Gere n números aleatórios entre 40 e 126 e depois converta-os em um caractere equivalente: (q parece ter apenas caracteres para estes)

`char$40+n?87

//Possible characters.
()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~

Exemplo de saída:

TVghrveVp Rpti+r0sea3a9nsIjuRXrAReJ; +di=ys`{ ikhKTe4trTZesz

EDIT:
salvou 3 bytes convertendo o q's raze em (, /) usando a notação k e alterou similarmente antes de `: Graças a @slackwear pela atualização, raspou 2 bytes :)

Adam J
fonte
1
pode salvar um par de bytes por fundição com10h$
skeevey
2

Java 8, 114 bytes

Golfe

(n,s)->s.chars().forEach((c)->{if(c>32)for(int i=0;i<=n;)System.out.print((char)(++i==1?c:33+Math.random()*94));})

Lambda que aceita um inteiro e uma string. Inspirado na resposta do Java 7, faça um loop duplo usando alguma sintaxe do Java 8 Stream (String.chars ) para economizar alguns bytes.

Entrada

3, "Hello world!"

Resultado

HfKIedb3l<-Ul%}vod"Bw\"|oa`%rH-}l/-{dMS;!B#X
Xanderhall
fonte
2

Scala, 95 94 bytes

def c(s:String,i:Int)=s.filter(_>32).mkString(scala.util.Random.alphanumeric.take(i).mkString)

Nada demais, além do uso de mkString em uma String. Ele trata a string como uma lista de caracteres e me permite inserir um separador entre eles. Meu separador é o número apropriado de caracteres alfanuméricos gerados aleatoriamente.

Ethan
fonte
Não chega a responder a pergunta. A natureza dos Random.alphanumericfará com que cada pedaço de ser o mesmo, por isso é uma cifra coxo ... Veja este exemplo:scala> c("Hello", 1) res0: String = Hbeblblbo
Jacob
BTW, você pode remover o filter. Invocar mkStringuma String o tratará como uma coleção de caracteres.
Jacob
@ Jacob, o filtro é a maneira mais eficiente que eu poderia pensar em remover espaços. Eu deixei o aleatório como está, pois parecia suficiente, mas se tiver tempo, adicionarei uma função separada para o texto aleatório apropriado.
Ethan
2

> <> (Peixe), 107 106 103 bytes

<v}:{r&" "
1xv+
2<v+
v}<
<~v!?=&:&:
6.>ol2-?!;a
:{{:}l1-[rv
v2<
<1x|!}:}-1<v!?:{{:o-+
^3<v ~}}r]~<
.40<

Experimente online!

Não é super aleatório, mas é aleatório. Apenas coloque a string e o número inteiro na pilha (exemplo: "Olá, mundo!", 5).

Input: "Hello world!", 5
Output: H^\^]^eceeedldcdeclgfffhowhhfggojkkkkrdccedl]]\]\d

Explicação completa

Esta é uma versão um pouco mais antiga do código, até que eu atualize a explicação. É basicamente o mesmo, apenas um pouco mais fácil de ler:

< v}:{r&" "
+1xv
+2<v
   }
:&:<~ v!?=&
?!;a6.>ol2-
:{{:}l1-[rv
v2<
<1x|!}:}-1<v!?:{{:o+*
^3<v ~}}r]~<
.43<

Vamos fingir que o parâmetro string é se o parâmetro inteiro é i.

< v}:{r&" "

O <comando diz ao peixe para mover-se imediatamente para a esquerda, o que envolve " ", o que adiciona um espaço na pilha. Em seguida, o peixe viaja &, o que adiciona espaço ao registro. rinverte a pilha e {:}desloca a pilha para a esquerda (colocando ino final da pilha), copia o valor no final da pilha e depois a desloca para a direita. vdiz ao peixe para começar a se mover para baixo.

+1xv
+2<v
   }

xdiz ao peixe para se mover em uma direção aleatória, resultando no peixe indo para a direita e continuando para baixo, ou passando por cima 1+ou 2+antes. Eles adicionam 1 ou 2, respectivamente, ao número no final da pilha. Se o peixe viaja para cima, bate vnovamente e volta para baixo. }desloca a pilha para a direita, tendo ina posição 1 na pilha e essa nova variável na posição 0 (a chamaremos m).

:&:<~ v!?=&

Esta seção é uma função, vamos chamá-la whitespaceTrimmer . Começa onde o< está. Ele simplesmente remove os espaços que estão no final da pilha (portanto, o início da string) até que ele seja executado em um caractere não espacial.

Então, imediatamente, o peixe nada <e deve viajar para a esquerda. Em seguida, ele é executado:&:& qual copia o valor no final da pilha, coloca o espaço do registrador no final da pilha, copia-o e o coloca novamente no registrador.

Então o peixe acerta =?!v ~, ou mais especificamente, =que retira os dois últimos valores (os dois que acabamos de criar) da pilha, os compara, coloca um 1 no final da pilha, se eles são iguais, e um 0 em o fim da pilha, se forem diferentes. A ?aparece o novo valor para fora da extremidade da pilha, se for 0 não executar a instrução seguinte, que neste caso é !, em vez disso é executado v, o que as ordens do peixe para se deslocar para baixo (de sair a função).

Se for 1, no entanto, ele encontrou um espaço, para executar o !que é um trampolim e fazer com que o peixe pule a próxima instrução, que é a v, para que o peixe continue. Na frente do peixe, ele vê o ~que diz para retirar o último valor da pilha (confirmado como um espaço), depois o peixe continua e executa a função novamente.

?!;a6.>ol2-

O peixe é instruído imediatamente a nadar para a direita com a e >, em seguida, gera o último caractere na pilha com o(o qual, a primeira vez que isso é executado, é o primeiro caractere s). Ele obtém o comprimento da pilha l, coloca um 2no final da pilha e -faz com que 2 sejam subtraídos l. Acerta o ?!;que, lembrando o que ?faz, faz com que o peixe pule !a pilha se estiver vazia e apareça ;, o que encerra o programa.

A seguir, se ainda houver caracteres na pilha, executamos o !que faz com que o peixe salte sobre ;e execute a6., que armazena a(AKA 10) e, 6no final da pilha, quais são as x, ycoordenadas ., o que os expõe no final do empilhar e depois teleporta o peixe para10, 6 e execute a instrução à direita dessa posição (como o peixe está nadando direito).

Isso é menos complicado do que parece quando você percebe que a yposição 6 é a linha abaixo desta. xposição 10 é então v, e à direita disso é , que é um no-op. Isso faz com que o peixe continue nadando direito e realmente comece a execução no início da linha ...

:{{:}l1-[rv
v2<
<1x|!}:}-1<v!?:{{:o+*
^3<v ~}}r]~<
.43<

Portanto, esta é a função que adiciona o texto aleatório entre os caracteres. É meio bocado, mas é só porque eu tentei torná-lo um pouco mais aleatório. Vamos chamar isso de genRandomChars .

Na :{{:}l1-[rvverdade, é a configuração da função e menos parte da própria função. O peixe nada primeiro sobre o :{{qual copia o valor no final da pilha e depois o desloca para a esquerda duas vezes. Se você se lembrar que iestava na posição 1 da pilha, você saberiai agora está no fim da pilha.

O peixe então nada sobre :}quais cópias ie desloca a pilha para a direita, colocando iambas no início e no final da pilha. l1-[faz com que o peixe coloque o comprimento no final da pilha, subtraia 1 e [crie uma nova pilha, movendo l-1(comprimento da pilha menos 1) os valores para a nova pilha (deixando apenas ia pilha antiga). Então o peixe simplesmente bate, o rvque inverte a pilha novamente (acho que a criação de uma nova pilha a inverte por algum motivo) e ordena que o peixe nade para baixo mais uma vez, começando verdadeiramente a função no< abaixo.

Então, atualmente, o fim da pilha tem me nosso temporário i, que chamaremos ti. Imediatamente o peixe nada 1-}, o que subtrai 1 tie o move para o início da pilha. Então, :}simplesmente copia me move-o para o início da pilha (colocando tina posição 1 da pilha).

É quando atingimos esta coisinha:

v2<
<1x|!
^3<

Isso é realmente simples demais. Isso !faz com que o peixe pule |e execute x. Lembrando o que xfaz, lembramos que isso faz o peixe se mover em qualquer 4 direções. |é simplesmente um espelho e faz com que o peixe volte a nadar x. Então, basicamente, o peixe colocará 1, 2 ou 3 no final da pilha e continuará se movendo para a esquerda, contornando.

O peixe então é executado, o *+oque faz com que os dois últimos valores na pilha sejam disparados, multiplicados juntos, e o resultado é pressionado novamente, em seguida, a mesma coisa com a adição e, em seguida, o valor final é disparado da pilha e gerado com ele o. Nossa pilha é agora relativamente normal novamente contendo apenas [ m, ti, s].

:}}:faz com que o valor no final da pilha (basicamente na sposição 0) não seja copiado, a pilha é deslocada para a direita duas vezes (colocando tina frente novamente) e depois tié copiada. ?!vdeve ser bem fácil de entender agora. Basicamente, se tifor 0, sairemos da função com v, caso contrário, executamos !e pulamos v(fazendo outro loop).

Se tifor 0 e terminamos de produzir caracteres ligeiramente aleatórios, executamos ve vemos:

   v ~}}r]~<
.43<

Nada muito chique aqui. Nós removemos tida pilha via ~. Então ]é novo, ele retira todos os nossos valores da pilha e os coloca na pilha antiga! Por causa da questão reversão nós revertemos com r, em seguida, mudar a pilha direita duas vezes com }}~, shufting a pilha para a direita, dando-nos [ m, i, s], o ~é para remover o adicional duplicado s[0]a partir no início da função que precisaríamos-lo se estávamos fazendo um loop (mas não estamos, estamos saindo). vdiz ao peixe para nadar para baixo e para dentro >34.(invertido para mostrar a ordem de execução), que diz ao peixe para nadar simplesmente para a esquerda e para dentro 3, 4(porque o. é um salto!). 3, 4é realmente apenas à direita do começowhitespaceTrimmer, o que é perfeito porque estamos viajando para a esquerda.

Seguindo toda essa lógica, podemos seguir o peixe até que a pilha esteja vazia e o programa saia logo após a whitespaceTrimmerexecução.

redstarcoder
fonte
Hmm, eu não vi que o personagem tivesse que ser imprimível. Isso exigirá pequenas modificações, o que pode torná-lo menos aleatório e menor.
Redstarcoder #
Realmente não parece muito menos aleatório. Acredito que deve funcionar na maioria dos casos, ainda não o tive. Ele funcionará com qualquer letra maiúscula ou minúscula, com certeza, e alguns símbolos. Tenho certeza de que isso atende aos requisitos do desafio.
Redstarcoder #
2

Perl 5, 81 bytes

($_,$n)=<>;chomp;y/ //d;$\=chop;print map{$_,map{chr 33+int rand 94}1..$n}split//

Espero que o seguinte ajude você a entender o que o one-liner faz:

($_, $n) = <STDIN>;  # Reads in the string into $_,
                     # and the number into $n, from standard input.
                     # (<STDIN> works slightly different from <>.)
chomp($_);           # Removes the newline from the string.
$_ =~ tr/ //d;       # `Tr/`ansliterates ASCII space characters
                     # into nothing, effectively `/d`eleting them.
$\ = chop($_);       # Chop()s off the last character out of $_ and
                     # appends it to the output when print()ing.
                     # (Perl always prints $\ after you call print().)
print( map {         # Each element of [List 1] will be mapped to:
    $_,              #   -- Itself, and
                     # (When mapping, each element is available as $_.)
    map {            # (`map` resembles `foreach` but returns a list.)
        chr(         #   -- A random ASCII character, in the range
          33 + int(rand(94)) ) # from 33 (!, hex 21) to 126 (~, hex 7E)
    } 1..$n          # ...$n times! (Over the range 1 to $n, actually.)
} split(//, $_) );   # [List 1] is $_, split() into characters.
g4v3
fonte
1

Clojure, 126 123 118 122 117 bytes

(defn c[m n](apply str(remove #(=\space %)(mapcat #(apply str %(for [_(range n)](char(rand-nth(range 32 127)))))m))))

Mapeia a mensagem, insere caracteres aleatórios e concatena o resultado.

As instruções sugerem que todos os espaços devem ser removidos da sequência de resultados. Se apenas espaços da mensagem original devem ser removidos, eu posso mudar isso.

Ungolfed:

(defn cipher [message n]
  (apply str
    (remove #(= \space %)
        (mapcat #(apply str %
                     (for [_ (range n)]
                       (char (rand-nth (range 32 127)))))
                message))))
Carcinigenicado
fonte
1

Python 3, 127 bytes

import random
a,b=input(),input()
print(''.join([x+''.join([chr(random.randint(33,126))for c in range(int(b))]) for x in a]))

Provavelmente muito mais tempo do que o necessário, mas este é o meu golfe até agora.

Vedvart1
fonte
1
Isso adiciona caracteres aleatórios na frente do primeiro caractere e os espaços não são aparados. Eu acho que essas duas coisas quebram as regras.
Stewie Griffin
1

PHP, 96 bytes

Toma String como argumento 1 e Number como argumento 2

for(;($s=str_replace(' ','',$argv[1]))[$j]>'';)echo$i++%($argv[2]+1)?chr(rand(33,127)):$s[$j++];

Experimente online

Crypto
fonte
1

Python 3, 133 bytes

from random import *
c=int(input())
print(''.join([i+''.join([chr(randint(33,126))for i in range(c)])for i in input().strip(' ')])[:-c])
sonrad10
fonte
1

Node.js, 88 bytes

(s,n)=>s.replace(/./g,c=>c!=" "?c+crypto.randomBytes(n).toString`base64`.substr(0,n):"")

Exemplo de saídas:

f("The treasure is here", 2)
// THphdwekAtMArbSeU1aDTsZWuqnr2yek1iyUsKshqXewvrVCeTi

f("The treasure is here", 2)
// TYshlcep6t4Iru7e29aQ1sl/uvQrlzeSJihysDhhOLe1urpte1m

Experimente online!

Florent
fonte
1

C, 102 100 bytes

-2 bytes para pular continue.

i;f(char*s,int n){do{while(*s==32)++s;putchar(*s);i=n;while(i--)putchar(32+rand()%95);}while(*s++);}

Ungolfed:

i;
f(char*s,int n){
 do{
  while(*s==32)++s;
  putchar(*s);
  i=n;
  while(i--)
    putchar(32+rand()%95);
 }while(*s++);
}

Uso:

main(){
  char a[]="A   A A";
  f(a,3);
}
Karl Napf
fonte