Introdução

Nas saídas de erro de algumas linguagens como Java, um ponteiro é mostrado para dar ao programador uma idéia exata de onde o erro deu errado.

Veja este exemplo no Ideone:

Main.java:12: error: ';' expected
    Invalid Java!
                ^

Observe que o sinal de intercalação mostra onde está o código inválido?

Desafio

Seu desafio é: dado número N e corda S , coloque um ponteiro no N º personagem em S .

Exemplos

Entrada :2, "Lorem ipsum, dollar sit amet."

Saída :

Lorem ipsum, dollar sit amet.
 ^

Regras

• A entrada é recebida via STDIN ou parâmetros de função
• A saída é impressa no console ou returned
• Trailing novas linhas, espaços etc são permitidos na saída
• O caractere do ponteiro deve ser um caractere ^ e deve estar em uma nova linha.
• Isso é código de golfe, então a resposta mais curta vence. Boa sorte!

C 33

Se apenas uma função é permitida, mesmo c pode competir.

(Para o registro, 2 bytes salvos thx no @Cool Guy. O comentário do Mt thx é evaporado inesperadamente.)

Mais 1 char economizado thx @Mig

f(a,c){printf("%s\n%*c",a,c,94);}

Brainf * ck - 133 bytes

+++++>>+>>+++>>+++++++++<<<<<<[[->++++++++++<]>>]<++++<<++<<<<--<,>[->+<<->]>>>,<<[->>-<<]<<[->>>>++++++++++<<<<]>>+[,.]>.>[->.<]>>>.

Espera entrada como, [0-9]{2}.*por exemplo, "02Olá mundo !!!" produziria

Olá Mundo!!!
 ^

Código de máquina IA-32, 24 bytes

Hexdump:

66 b8 5e 00 42 38 22 75 fb 66 c7 02 0d 0a 42 42
c6 02 20 e2 fa 89 02 c3

É uma função (usando a fastcallconvenção da MS ) que atualiza a string no local:

__declspec(naked) void __fastcall carrot(int n, char* s)

Código de montagem:

    mov ax, '^'; // ah = 0, al = '^'

mystrlen:
    inc edx;
    cmp [edx], ah;
    jne mystrlen;

    mov word ptr [edx], '\r\n'; // append a newline
    inc edx;

mymemset:
    inc edx;
    mov byte ptr [edx], ' ';
    loop mymemset;

    mov [edx], eax; // append a caret and terminate the string
    ret;

Ele usa dados de WORDtamanho (16 bits) em alguns lugares. Isso tem uma penalidade (prefixo de 1 byte) no código de 32 bits, mas diminui o código de qualquer maneira - o uso de dados de 32 bits colocaria dois bytes zero no código!

No final, ele grava 4 bytes ( eax) em vez de 2 bytes ( ax) - o código é menor dessa maneira e 2 bytes extras de lixo eletrônico são eliminados após o término da string, para que ninguém os note.

Uso:

int main()
{
    char s[100] = "Lorem ipsum, euro sit amet.";
    carrot(2, s); // credit to Digital Trauma for the name
    puts(s);
}

Pitão , 8

zp\^*tQd

Essa solução não funciona mais, pois o commit após o qual eu pvinculei como o nome do idioma mudou para ter aridade 1. Existem várias outras maneiras de obter uma pontuação semelhante no Pyth que ainda funcionam hoje, como zp+*dQ\^.

Se a sequência precisar de aspas, adicionar vao início do código funcionará. Se tiver que ser separado por vírgula, aumentará para 10 bytes:

eQp\^*dthQ

T-SQL, 90

Embora seja uma pergunta bastante simples, é sempre interessante experimentá-las em idiomas que realmente não tendem a apoiá-los ou jogar bem nesse assunto.

É quase garantido que esta resposta seja a mais longa.

Isso cria uma função de tabela embutida para o SQL Server que usa @n e @ como parâmetros e retorna os resultados como uma coluna. O retorno de carro é significativo, caso contrário eu precisaria usar char (13).

CREATE FUNCTION G(@N INT,@ VARCHAR(MAX))RETURNS TABLE RETURN SELECT @+'
'+SPACE(@n-1)+'^'R

É usado da seguinte maneira

SELECT R 
FROM (VALUES
    (1,'This is test 1'),
    (2,'This is test 2'),
    (3,'This is test 3'),
    (4,'This is test 4'),
    (5,'This is test 5')
    )T(n,S)
    CROSS APPLY G(n,S)

E retorna

R
---------------
This is test 1
^
This is test 2
 ^
This is test 3
  ^
This is test 4
   ^
This is test 5
    ^

Python, 27

lambda n,s:s+'\n%%%dc'%n%94

Isso usa dois níveis de formatação de string.

E aqui está uma solução de 25 bytes , parcialmente roubada da resposta do feersum (com a ordem dos argumentos invertida):

lambda*p:'%s\n%%%dc'%p%94

Bash, 27

printf %s\\n%$[$1-1]s^ "$2"

Resultado

$ ./carrot.sh 2 "Lorem ipsum, dollar sit amet."
Lorem ipsum, dollar sit amet.
 ^$ 

Python, 29

lambda n,s:s+'\n'+' '*~-n+'^'

Concatena a sequência, uma nova linha, n-1espaços e a ^.

sed, 16

2y/1/ /;2s/ $/^/

Isso é uma espécie de caixa de teste dessa meta resposta . Especificamente, estou exigindo que o número N seja inserido como unário. Por exemplo, para o cursor na posição 2, a entrada para N seria 11. Também não está estritamente especificado qual ordem S e N deve ser, então aqui S vai primeiro, seguido por N unário em uma nova linha, por todo STDIN.

Resultado:

$ { echo "Lorem ipsum, dollar sit amet."; echo 11; } | sed '2y/1/ /;2s/ $/^/'
Lorem ipsum, dollar sit amet.
 ^
$

JavaScript (ES6): 63 62 56 52 32 bytes

Agradecemos ao nderscore por reduzir bastante o tamanho do código.

p=(a,b)=>b+`\n${' '.repeat(a)}^`

Versão que funciona em mais navegadores (47 bytes):

p=function(a,b){return b+`\n${' '.repeat(a)}^`}

CJam, 9 bytes

q~N@(S*'^

Experimente online.

Como funciona

q~  e# Read the input from STDIN and interpret it.
    e# This pushes the integer and the string on the stack.
N@  e# Push a linefeed an rotate the integer on top of it.
(S* e# Subtract 1 and push a string consisting of that many spaces.
'^  e# Push a caret.

Python, 29

Aqui está uma maneira mais divertida de fazer isso em 29:

lambda*p:'%s\n%*s'%(p+('^',))

Exemplo de uso:

>>> f=lambda*p:'%s\n%*s'%(p+('^',))
>>> print f('lorem',5)
lorem
    ^

TI-BASIC, 10 (?) Bytes

Disp Ans
Output(3,N,"^

A entrada é fornecida na variável N, conforme a pergunta, mas você não pode usar a letra var S como uma string. Em lugar disso, é preciso entrada para a cadeia de Ans, de modo a executar o exemplo no OP: 2->N:"Lorem ipsum, dollar sit amet.":prgm<program name>.

Estou ciente de que isso provavelmente não conta, pois cada segmento delimitado por dois pontos é tecnicamente uma declaração separada; aqui está um programa de 46 bytes que recebe entrada como N "S"( 2 "Lorem ipsum, dollar sit amet.")

Input Str1
2+inString(Str1," 
//^there's a space after the quote
Disp sub(Str1,Ans,length(Str1)-Ans
Output(4,expr(sub(Str1,1,1)),"^

Ambos assumem que a tela foi limpa antes da execução.

dc, 19

?pr256r^255/32*62+P

A entrada é de STDIN. dcstrings são definições de macro e estão contidas em [ ]. A sequência de espaços é gerada calculando o número que, quando expresso como um fluxo base de 256 bytes, fornece a sequência necessária. O cálculo é ((n ^ 256) / 255) * 32). Isso fornece nespaços (caractere ASCII 32), mas precisamos n-1segui-los ^, portanto, basta adicionar 62 ao último dígito base de 256.

Resultado

$ dc -e '?pr256r^255/32*62+P' <<< "2 [Lorem ipsum, dollar sit amet.]"
Lorem ipsum, dollar sit amet.
 ^$

C, 59 57 47 bytes

f(a,c){for(puts(a);--c;putchar(32));puts("^");}

Bem direto. Versão não destruída:

f(char* a,int c){
    puts(a);        //Print the string first

    for(;--c;)      //Until number-1 is not 0
        putchar(32);//Print a space
    puts("^");      //Print a caret
}

Teste aqui
Graças a @anatolyg por economizar 10 bytes!

C # 55

Uma função, conceito semelhante à minha resposta C, mas esse retorno de tempo é menor que a saída.

string f(string a,int b){return a+'\n'+"^".PadLeft(b);}

SAS, 35 bytes

%macro a(n,s);put &s/@&n."^";%mend;

Esse é o equivalente do SAS a uma função nua; adicionar a etapa de dados para chamá-lo (equivalente à função principal C para chamá-lo) seria um pouco mais (9 bytes a mais - Ty Alex), mas acho que isso não é necessário para esse fim. Como seria chamado:

data;
%a(3,"My String");
run;

Existe uma implementação somente de macro, mas é muito mais longa, mesmo que você permita que ele avise sobre parâmetros inválidos em n = 1.

Se pudéssemos usar parâmetros predefinidos, o SAS seria relativamente curto nesse caso, o que é uma raridade para um idioma que definitivamente não pretende ser curto.

Se um conjunto de dados pode ser a fonte de entrada, é como você o faria no SAS (ou por instruções% let), mas provavelmente não é permitido, isso é ainda mais curto ( 27 bytes , que na verdade pode ser 25). se você garantiu que o conjunto de dados foi construído imediatamente antes de executar isso [como você poderia usar set;]]):

(conjunto de dados pré-existente)

data b;
  n=3;
  s="My String";
run;

(código real)

data;set b;put s/@n"^";run;

Matlab / Octave, 41

@(n,s)sprintf('%s\n%s^',s,ones(1,n-1)+31)

Esta é uma função anônima que retorna a string. Isso produz um aviso, que pode ser suprimido pela chamada anterior warning off.

K, 21 bytes

{y,"\n",1_|"^",x#" "}

Exemplo:

ryan@DevPC-LX:~/golf/caret$ rlwrap k
K Console - Enter \ for help

  `0:{y,"\n",1_|"^",x#" "}[2;"Lorem ipsum, dollar sit amet."]
Lorem ipsum, dollar sit amet.
 ^  

Explicação ( xé o número, yé a sequência):

{                   }   enclosing function
               x#" "    repeat the space `x` times
           "^",         prepend the caret
          |             reverse the string to put the caret at the end
        1_              drop the extra space
   "\n",                prepend a newline
 y,                     prepend the text

R, 49 48 46

Como uma função sem nome que gera STDOUT. Obrigado a @Flounderer pela melhoria.

usa strwrap agora para identificar o sinal de intercalação para n-1. cat usa um separador de \ n em vez de uma string vazia.

function(n,s)cat(s,strwrap('^',,n-1),sep='\n')

Execução de teste

> f=function(n,s)cat(s,strwrap('^',,n-1),sep='\n')
> f(29,'The caret should point here v hopefully')
The caret should point here v hopefully
                            ^
>

Python3, 38 36 bytes

def f(s,i):return s+'\n'+' '*~-i+'^'

# OR 

def f(s,i):print(s+'\n'+' '*~-i+'^')

Teste aqui!
Obrigado ao @Dennis por economizar 2 bytes!

Julia, 27 bytes

(n,s)->s*"\n"*" "^(n-1)*"^"

Isso cria uma função sem nome que aceita um número inteiro e uma string como entrada e retorna uma string. Para chamá-lo, dê um nome, por exemplo f=(n,s)->....

Tudo o que está acontecendo aqui é que estamos acrescentando uma nova linha, n-1espaços e o sinal de intercalação. A concatenação de strings é realizada usando *e repetição de strings com ^.

Ungolfed:

function f(n, s)
    s * "\n" * " "^(n-1) * "^"
end

Exemplo:

julia> println(f(2, "Lorem ipsum, dollar sit amet."))
Lorem ipsum, dollar sit amet.
 ^

PHP (CLI) - 42

<?=sprintf("%s\n%$argv[1]s",$argv[2],'^');

Chame a partir da linha de comando:

php pointer.php 2 "Lorem ipsum, dollar sit amet."

Matlab, 25

Este é extremamente atrevido. Aparentemente, exibe imprime caracteres não imprimíveis como espaços. O código a seguir define uma função chamada ans, que atende às especificações.

@(N,S)[S 10 ones(N-1) 94]

chamando essa função assim:

ans(2, 'Lorem ipsum, dollar sit amet.')

dá a saída:

ans =

Lorem ipsum, dollar sit amet.
 ^

Eu sempre não gosto da ans =parte das respostas do Matlab. Se isso for um problema, preciso adicionar 6 bytes ... mas sempre o vi assim nas respostas do Matlab. Observe que a execução desse código substitui a variável ans; portanto, você precisa redefinir a função se quiser usá-la uma segunda vez!

Minha primeira chance no codegolf

Java, 133 65

String g(int i,String s){for(s+="\n";--i>0;)s+=" ";return s+"^";}

Tenho certeza que pode ser reduzido ainda mais.

Código antigo

public void go(int i,String s){System.out.println(s);IntStream.range(1,i).forEach(j->System.out.print(" "));System.out.println("^");}

Swift, 41

É decepcionante que o Swift não tenha o operador *ligado Arrayou String.

{$1+reduce(0..<$0,"\n",{$0.0+" "})+"^"}

EspecificaçõesBAS - 34

1 INPUT n,s$: PRINT s$'TAB n-1;"^"

O apóstrofo PRINTforça uma nova linha, basta mover o cursor para a posição correta.

GolfScript 11

n@~(' '*'^'

Teste aqui .

JavaScript - 52 bytes

Aqui está o meu, é bem simples.

function f(n,s){return s+"\n"+Array(n).join(" ")+"^"}

Uso:

$ console.log(f(7, "Any string at all"))

Any string at all
      ^

Aponta para o sétimo caractere.

Perl 5, 31

sub{"$_[0]
"." "x($_[1]-1)."^"}