introduction

Dans les sorties d'erreur de certains langages tels que Java, un pointeur est montré pour donner au programmeur une idée de l'endroit exact où l'erreur s'est produite.

Prenons cet exemple sur Ideone:

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

Notez que le curseur indique où se trouve le code invalide?

Défi

Votre défi est: nombre donné N et chaîne S , placez un pointeur sur la N ième caractère S .

Exemples

Entrée :2, "Lorem ipsum, dollar sit amet."

Sortie :

Lorem ipsum, dollar sit amet.
 ^

Règles

• L'entrée est reçue via STDIN ou des paramètres de fonction
• La sortie est imprimée sur la console ou returned
• Les nouvelles lignes, espaces, etc. sont autorisés dans la sortie
• Le caractère de pointeur doit être un ^ caret et doit figurer sur une nouvelle ligne.
• C'est le code de golf, donc la réponse la plus courte gagne. Bonne chance!

C 33

Si seulement une fonction est autorisée, alors même c peut concourir.

(Pour mémoire, 2 octets enregistrés sur ThC @ Guy Cool. Le commentaire de Thx s'est évaporé de manière inattendue.)

1 caractère de plus enregistré thx @Mig

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

Brainf * ck - 133 octets

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

Attend l'entrée comme [0-9]{2}.*par exemple "02Hello world !!!" produirait

Bonjour le monde!!!
 ^

IA-32 code machine, 24 octets

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

C'est une fonction (utilisant la fastcallconvention MS ) qui met à jour la chaîne sur place:

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

Code d'assemblage:

    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;

Il utilise des données de WORDtaille (16 bits) à quelques endroits. Cela a une pénalité (préfixe de 1 octet) dans le code 32 bits, mais rend le code plus petit de toute façon - utiliser des données 32 bits mettrait deux octets à zéro dans le code!

À la fin, il écrit 4 octets ( eax) au lieu de 2 octets ( ax) - le code est plus petit de cette façon et 2 octets supplémentaires d’ordure disparaissent après la fin de la chaîne, de sorte que personne ne les remarque.

Usage:

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

Cette solution ne fonctionne plus, car le commit suivant celui pauquel je me suis associé lorsque le nom de la langue a changé a été remplacé par arity 1. Il existe plusieurs autres moyens de réaliser un score similaire en Pyth qui fonctionnent encore de nos jours, comme zp+*dQ\^.

Si la chaîne nécessite des guillemets, l'ajout vau début du code fonctionne. S'il doit être séparé par des virgules, il peut aller jusqu'à 10 octets:

eQp\^*dthQ

T-SQL, 90

Bien qu’il s’agisse d’une question assez simple, il est toujours intéressant d’essayer ces langues dans des langues qui ne les supportent pas vraiment bien ou qui ne jouent pas bien au golf.

Cette réponse est presque certainement la plus longue.

Cela crée une fonction de table en ligne pour SQL Server qui prend les paramètres @n et @ et renvoie les résultats sous forme de colonne. Le retour de voiture est important, sinon je devrais utiliser le caractère (13).

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

Il est utilisé de la manière suivante

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)

Et revient

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

Ceci utilise deux niveaux de formatage de chaîne.

Et voici une solution de 25 octets partiellement volée dans la réponse de feersum (avec l'argument ordre inversé):

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

Bash, 27 ans

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

Sortie

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

Python, 29 ans

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

Concatène la chaîne, une nouvelle ligne, des n-1espaces et une ^.

sed, 16

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

C'est en quelque sorte un test de cette méta réponse . Plus précisément, je demande que le nombre N soit entré unaire. Par exemple, pour le curseur en position 2, l'entrée pour N serait 11. De plus, il n'est pas strictement spécifié quel ordre doit être S et N , alors S commence, puis N unaire sur une nouvelle ligne, tout au long de STDIN.

Sortie:

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

JavaScript (ES6): 63 62 56 52 32 octets

Merci à nderscore pour avoir considérablement réduit la taille du code.

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

Version qui fonctionne sur plusieurs navigateurs (47 octets):

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

CJam, 9 octets

q~N@(S*'^

Essayez-le en ligne.

Comment ça fonctionne

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 ans

Voici une façon plus amusante de le faire en 29:

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

Exemple d'utilisation:

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

TI-BASIC, 10 (?) Octets

Disp Ans
Output(3,N,"^

L'entrée est donnée dans la variable N, comme le demande la question, mais vous ne pouvez pas utiliser la lettre var S en tant que chaîne. Au lieu de cela, il prend entrée de chaîne de Ans, pour ainsi exécuter l'exemple dans l'OP: 2->N:"Lorem ipsum, dollar sit amet.":prgm<program name>.

Je suis conscient que cela ne compte probablement pas, car chaque segment délimité par des deux-points est techniquement une déclaration distincte; voici un programme de 46 octets qui prend en entrée comme 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)),"^

Les deux supposent que l'écran a été effacé avant l'exécution.

dc, 19

?pr256r^255/32*62+P

L'entrée provient de STDIN. dcles chaînes sont des définitions de macros contenues dans [ ]. La chaîne d'espaces est générée en calculant le nombre qui, lorsqu'il est exprimé en tant que flux de base de 256 octets, donne la chaîne dont nous avons besoin. Le calcul est ((n ^ 256) / 255) * 32). Cela donne des nespaces (caractère ASCII 32), mais nous avons besoin de n-1suivi de ^, nous ajoutons donc simplement 62 au dernier chiffre de base de 256 chiffres.

Sortie

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

C, 59 57 47 octets

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

Assez simple. Version non-golfée:

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
}

Testez-le ici
Merci à @anatolyg d' avoir économisé 10 octets!

C # 55

Une fonction, concept similaire à ma réponse C, mais cette fois le retour est plus court que la sortie.

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

SAS, 35 octets

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

C'est l'équivalent SAS d'une fonction nue; ajouter l'étape de données pour l'appeler (l'équivalent de la fonction principale C pour l'appeler) serait un peu plus (9 octets de plus - Ty Alex), mais je pense que ce n'est pas nécessaire pour cela. Comment ça s'appellerait:

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

Il existe une implémentation macro uniquement mais elle est beaucoup plus longue, même si vous lui permettez de donner un avertissement concernant les paramètres non valides sur n = 1.

Si nous pouvions utiliser des paramètres prédéfinis, SAS serait relativement court par rapport à celui-ci, ce qui est une rareté pour une langue qui n’est certainement pas destinée à être courte.

Si un jeu de données est autorisé à être la source d'entrée, ce qui est le cas de la manière dont vous le feriez dans SAS (ou à l'aide d'instructions% let), sans que cela ne soit probablement pas autorisé, le délai est encore plus court ( 27 octets , ce qui pourrait en réalité être 25 si vous avez garanti que le jeu de données a été construit immédiatement avant d'exécuter ceci [comme vous pouvez simplement l'utiliser set;]):

(ensemble de données préexistant)

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

(code actuel)

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

Matlab / Octave, 41 ans

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

C'est une fonction anonyme qui renvoie la chaîne. Cela produit un avertissement qui peut être supprimé en appelant précédemment warning off.

K, 21 octets

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

Exemple:

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

Explication ( xest le nombre, yest la chaîne):

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

En tant que fonction non nommée qui sort vers STDOUT. Merci à @Flounderer pour l'amélioration.

utilise maintenant strwrap pour identifier le curseur avec n-1. cat utilise un séparateur de \ n plutôt qu'une chaîne vide.

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

Essai

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

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

# OR 

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

Testez-le ici
Merci à @Dennis d' avoir économisé 2 octets!

Julia, 27 octets

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

Cela crée une fonction non nommée qui accepte un entier et une chaîne en tant qu'entrée et renvoie une chaîne. Pour l'appeler, donnez-lui un nom, par exemple f=(n,s)->....

Tout ce qui se passe ici, c'est que nous ajoutons une nouvelle ligne, des n-1espaces et le curseur. La concaténation de chaînes est effectuée à l'aide de *et la répétition de chaînes avec ^.

Ungolfed:

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

Exemple:

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

Appelez-le depuis la ligne de commande:

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

Matlab, 25 ans

Celui-ci est extrêmement effronté. Apparemment, affiche imprime des caractères non imprimables sous forme d'espaces. Le code suivant définit une fonction nommée ans, qui répond aux spécifications.

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

appelant ainsi cette fonction comme ceci:

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

donne le résultat:

ans =

Lorem ipsum, dollar sit amet.
 ^

Je n'aime toujours pas la ans =partie dans Matlab répond. Si cela pose un problème, je dois ajouter 6 octets ... mais je l’ai toujours vu ainsi dans les réponses Matlab. Notez que l'exécution de ce code écrase la variable ans, vous devez donc redéfinir la fonction si vous souhaitez l'utiliser une seconde fois!

Mon premier coup au codegolf

Java, 133 65

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

Je suis sûr que cela peut être réduit encore plus.

Ancien code

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 ans

Il est décevant que Swift n'ait pas d'opérateur *sur Arrayou String.

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

SpecBAS - 34

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

Apostrophe PRINTforce une nouvelle ligne, puis il suffit de déplacer le curseur pour le positionner correctement.

GolfScript 11

n@~(' '*'^'

Testez ici .

JavaScript - 52 octets

Voici le mien, c'est assez simple.

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

Usage:

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

Any string at all
      ^

Il pointe vers le septième caractère.

Perl 5, 31

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