introduzione

Negli output degli errori di alcune lingue come Java, viene mostrato un puntatore per dare al programmatore un'idea di dove esattamente l'errore è andato storto.

Prendi questo esempio su Ideone:

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

Notate che il cursore mostra dove si trova il codice non valido?

Sfida

La vostra sfida è: dato numero N e la stringa S , posizionare il puntatore sul N ° personaggio in S .

Esempi

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

Uscita :

Lorem ipsum, dollar sit amet.
 ^

Regole

• L'ingresso viene ricevuto tramite STDIN o parametri di funzione
• L'output viene stampato sulla console o returned
• Trascinare nuove righe, spazi ecc. Sono consentiti nell'output
• Il carattere puntatore deve essere un cursore ^ e deve trovarsi su una nuova riga.
• Questo è il codice golf, quindi vince la risposta più breve. In bocca al lupo!

C 33

Se è consentita solo una funzione, anche c può competere.

(Per la cronaca, 2 byte salvati grazie a @Cool Guy. Il commento Mt thx viene evaporato inaspettatamente.)

1 altro carattere salvato thx @Mig

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

Brainf * ck - 133 byte

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

Si aspetta input come [0-9]{2}.*ad es. "02Hello world !!!" produrrebbe

Ciao mondo!!!
 ^

Codice macchina IA-32, 24 byte

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

È una funzione (che utilizza la fastcallconvenzione MS ) che aggiorna la stringa sul posto:

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

Codice dell'Assemblea:

    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;

Utilizza dati di WORDdimensioni ridotte (16 bit) in alcuni punti. Questo ha una penalità (prefisso a 1 byte) nel codice a 32 bit, ma rende comunque il codice più piccolo - l'uso di dati a 32 bit metterebbe due byte zero nel codice!

Alla fine, scrive 4 byte ( eax) anziché 2 byte ( ax) - il codice è più piccolo in questo modo e 2 byte extra di posta indesiderata vanno dopo la fine della stringa, quindi nessuno se ne accorge.

Uso:

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

Pyth , 8

zp\^*tQd

Questa soluzione non funziona più, dal momento che il commit dopo quello a cui mi sono collegato come il nome della lingua è cambiato pin arity 1. Ci sono molti altri modi per ottenere un punteggio simile in Pyth che funzionano ancora oggi, come zp+*dQ\^.

Se la stringa necessita di virgolette, l'aggiunta vall'inizio del codice funziona. Se deve essere separato da virgola, arriva fino a 10 byte:

eQp\^*dthQ

T-SQL, 90

Mentre una domanda abbastanza semplice, è sempre interessante provarli in lingue che in realtà non tendono a sostenerli bene o giocare bene a golf.

Questa risposta è quasi garantita per essere la più lunga.

Ciò crea una funzione di tabella incorporata per SQL Server che accetta @n e @ come parametri e restituisce i risultati come colonna. Il ritorno del trasporto è significativo, altrimenti avrei bisogno di usare char (13).

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

È usato nel modo seguente

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 ritorna

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

Questo utilizza due livelli di formattazione delle stringhe.

Ed ecco una soluzione da 25 byte in parte rubata dalla risposta di feersum (con l'ordine degli argomenti invertito):

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

Bash, 27

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

Produzione

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

Python, 29

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

Concatena la stringa, una nuova riga, gli n-1spazi e una ^.

sed, 16

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

Questa è una sorta di testcase di questa meta risposta . In particolare, sto richiedendo che il numero N sia inserito in unario. Ad esempio per il cursore in posizione 2, l'ingresso per N sarebbe 11. Inoltre non è strettamente specificato quale ordine S e N dovrebbero essere, quindi qui S va per primo, seguito da N unario su una nuova linea, tutto attraverso STDIN.

Produzione:

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

JavaScript (ES6): 63 62 56 52 32 byte

Grazie a nderscore per ridurre notevolmente le dimensioni del codice.

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

Versione che funziona su più browser (47 byte):

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

CJam, 9 byte

q~N@(S*'^

Provalo online.

Come funziona

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

Ecco un modo più divertente per farlo in 29:

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

Esempio di utilizzo:

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

TI-BASIC, 10 (?) Byte

Disp Ans
Output(3,N,"^

L'input viene dato nella variabile N, come viene posta la domanda, ma non è possibile utilizzare la lettera var S come stringa. Al posto di ciò, riceve l'input stringa dal Ans, in modo da eseguire l'esempio nel PO: 2->N:"Lorem ipsum, dollar sit amet.":prgm<program name>.

Sono consapevole che probabilmente ciò non conta, poiché ogni segmento delimitato da due punti è tecnicamente un'istruzione separata; ecco un programma a 46 byte che accetta input come 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)),"^

Entrambi presuppongono che lo schermo sia stato cancellato prima di essere eseguito.

dc, 19

?pr256r^255/32*62+P

L'ingresso è da STDIN. dcle stringhe sono definizioni macro e contenute in [ ]. La stringa di spazi viene generata calcolando il numero che quando espresso come flusso di 256 byte di base fornisce la stringa di cui abbiamo bisogno. Il calcolo è ((n ^ 256) / 255) * 32). Questo dà nspazi (carattere ASCII 32), ma dobbiamo n-1seguirci ^, quindi aggiungiamo semplicemente 62 all'ultima base di 256 cifre.

Produzione

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

C, 59 57 47 byte

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

Abbastanza diretto. Versione non golfata:

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
}

Provatelo qui
Grazie a @anatolyg per il salvataggio di 10 byte!

C # 55

Una funzione, concetto simile alla mia risposta C, ma questa volta il ritorno è più breve dell'output.

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

SAS, 35 byte

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

Questo è l'equivalente SAS di una funzione nuda; aggiungere il passaggio di dati per chiamarlo (equivalente alla funzione principale C per chiamarlo) sarebbe un po 'più (9 byte in più - Ty Alex), ma penso che non sia necessario per questo scopo. Come sarebbe chiamato:

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

Esiste un'implementazione solo macro ma è molto più lunga, anche se si consente di dare un avviso sui parametri non validi su n = 1.

Se potessimo utilizzare parametri predefiniti, SAS sarebbe piuttosto breve rispetto a questo, il che è una rarità per un linguaggio che sicuramente non è destinato ad essere breve.

Se un set di dati può essere la fonte di input, che è il modo in cui lo si farebbe in SAS (o con% let istruzioni), ma probabilmente non è permesso, questo è ancora più breve ( 27 byte , che in realtà potrebbe essere 25 se hai garantito che il set di dati è stato creato immediatamente prima dell'esecuzione di questo [come potresti usare set;]]:

(set di dati preesistente)

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

(codice attuale)

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

Matlab / Octave, 41

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

Questa è una funzione anonima che restituisce la stringa. Questo produce un avviso, che può essere soppresso chiamando in precedenza warning off.

K, 21 byte

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

Esempio:

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.
 ^  

Spiegazione ( xè il numero, yè la stringa):

{                   }   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

Come una funzione senza nome che viene emessa su STDOUT. Grazie a @Flounderer per il miglioramento.

usa strwrap ora per identificare il cursore su n-1. cat utilizza un separatore di \ n anziché una stringa vuota.

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

Prova

> 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 byte

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

# OR 

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

Provatelo qui
Grazie a @Dennis per il salvataggio di 2 byte!

Julia, 27 byte

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

Ciò crea una funzione senza nome che accetta un numero intero e una stringa come input e restituisce una stringa. Per chiamarlo, dagli un nome, ad es f=(n,s)->....

Tutto ciò che sta accadendo qui è che stiamo aggiungendo una nuova riga, n-1spazi e il cursore. La concatenazione di stringhe viene eseguita utilizzando *e ripetizione di stringa con ^.

Ungolfed:

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

Esempio:

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],'^');

Chiamalo dalla riga di comando:

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

Matlab, 25

Questo è estremamente sfacciato. Apparentemente visualizza stampe caratteri non stampabili come spazi. Il codice seguente definisce una funzione denominata ans, che soddisfa le specifiche.

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

quindi chiamando questa funzione in questo modo:

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

dà l'output:

ans =

Lorem ipsum, dollar sit amet.
 ^

Non mi piace sempre la ans =parte nelle risposte di Matlab. Se questo è un problema, devo aggiungere 6 byte ... ma l'ho sempre visto così nelle risposte a Matlab. Si noti che l'esecuzione di questo codice sovrascrive la variabile ans, quindi è necessario ridefinire la funzione se si desidera utilizzarla una seconda volta!

Il mio primo colpo a codegolf

Java, 133 65

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

Sono sicuro che può essere ridotto ancora di più.

Vecchio codice

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

È deludente che Swift non abbia un operatore *attivo Arrayo String.

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

SpecBAS - 34

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

L'apostrofo PRINTforza una nuova linea, quindi basta spostare il cursore nella posizione corretta.

GolfScript 11

n@~(' '*'^'

Prova qui .

JavaScript - 52 byte

Ecco il mio, è piuttosto semplice.

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

Uso:

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

Any string at all
      ^

Indica il settimo personaggio.

Perl 5, 31

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