introduction

Kipple est un langage de programmation ésotérique basé sur une pile inventé par Rune Berg en mars 2003.

Kipple a 27 piles, 4 opérateurs et une structure de contrôle.

Piles

Les piles sont nommés a- zet contiennent des entiers signés 32 bits. Il existe également une pile spéciale @pour rendre la sortie des numéros plus pratique. Lorsqu'un numéro est poussé @, les valeurs ASCII des chiffres de ce numéro sont en fait poussées à la place. (Par exemple, si vous appuyez sur 12 vers @, il poussera 49 puis 50 vers à la @place.)

L'entrée est poussée sur la pile d'entrée iavant l'exécution du programme. L'interprète demandera des valeurs à stocker iavant l'exécution. Une fois l'exécution terminée, tout ce qui se trouve sur la pile de sortie oest renvoyé à la sortie sous forme de caractère ASCII. Comme il s'agit du seul mécanisme d'E / S de Kipple, l'interaction avec un programme Kipple est impossible.

Les opérateurs

Un opérande est soit un identifiant de pile, soit un entier 32 bits signé.

Appuyez: >ou<

Syntaxe: Operand>StackIndentifierouStackIndentifier<Operand

L'opérateur Push prend l'opérande vers la gauche et le pousse sur la pile spécifiée. Par exemple, 12>apoussera la valeur 12 sur la pile a. a>bfera apparaître la valeur la plus élevée de la pile aet la poussera sur la pile b. Popping une pile vide renvoie toujours 0. a<best équivalent à b>a. a<b>caffiche la valeur la plus élevée de bet pousse à la fois sur cet a.

Ajouter: +

Syntaxe: StackIndentifier+Operand

L'opérateur Ajouter pousse la somme de l'élément le plus haut de la pile et de l'opérande sur la pile. Si l'opérande est une pile, la valeur en est extraite. Par exemple, si la valeur la plus élevée de la pile aest 1, alors a+2poussera 3 dessus. Si aest vide, alors a+2poussera 2 dessus. Si les valeurs les plus élevées de la pile aet bsont 1 et 2, alors a+bsautera la valeur 2 de la pile bet poussera 3 sur la pile a.

Soustraire: -

Syntaxe: StackIndentifier-Operand

L'opérateur Soustraire fonctionne exactement comme l'opérateur Ajouter, sauf qu'il soustrait au lieu d'ajouter.

Clair: ?

Syntaxe: StackIndentifier?

L'opérateur Clear vide la pile si son élément le plus haut est 0.

L'interprète ignore tout ce qui est pas à côté de l'opérateur, de sorte que le programme suivant fonctionnerait: a+2 this will be ignored c<i. Cependant, la bonne façon d'ajouter des commentaires est d'utiliser le #caractère. Tout ce qui se trouve entre un #et un caractère de fin de ligne est supprimé avant l'exécution. Le caractère ASCII # 10 est défini comme fin de ligne dans Kipple.

Les opérandes peuvent être partagés par deux opérateurs, par exemple a>b c>b c?peuvent être écrits comme a>b<c?.

Le programme 1>a<2 a+ase traduira par acontenir les valeurs [1 4](de bas en haut) et non [1 3]. De même pour l' -opérateur.

La structure de contrôle

Il n'y a qu'une seule structure de contrôle dans Kipple: la boucle.

Syntaxe: (StackIndentifier code )

Tant que la pile spécifiée n'est pas vide, le code entre parenthèses correspondant sera répété. Les boucles peuvent contenir d'autres boucles. Par exemple, (a a>b)déplace toutes les valeurs de pile asur pile b, bien que l'ordre soit inversé . Une façon fonctionnellement identique mais plus élégante de le faire est (a>b).

Exemples

100>@ (@>o)

Cela produira 100

33>o 100>o 108>o 114>o 111>o 87>o 32>o 111>o 108>o 108>o 101>o 72>o

Cela s'imprimera "Hello World!". Lorsque la opile est en cours de sortie, elle commence à faire apparaître des caractères du haut vers le bas.

#prime.k by Jannis Harder
u<200
#change 200


k<2>m
u-2
(u-1 u>t u>z u<t
  (k>e e+0 e>r)
  (e>k)
  m+1
  m>t
  m>z
  m<t
  t<0>z? t?
  1>g
  (r>b
    m+0 m>a
    b+0 b>w
    (a-1 
      b+0 b>j
      j?
      1>s
      (j<0>s j?)
      s?
      (s<0 w+0 w>b s?)
      a>t
      a>z
      t>a
      b-1
      b>t
      b>z
      t>b
      z<0>t? z?
    a?)
    b?
    1>p
    (b<0 b? 0>p)
    p?
    (p 0>r? 0>p? 0>g)
  )
  g?
  (g m+0 m>k 0>g?)
u?)
(k>@
  10>o
  (@>o)
)

Ceci est un générateur de nombres premiers, mais je ne sais pas comment cela fonctionne.

Règles

• Vous devez écrire un programme / fonction qui interprète Kipple. Ce programme / fonction peut obtenir un programme Kipple via un fichier source, ou l'obtenir via STDIN directement auprès de l'utilisateur. Si STDIN n'est pas disponible, il doit l'obtenir à partir de la saisie au clavier et continuer à obtenir la saisie jusqu'à ce qu'un caractère non imprimable spécifique soit entré. Par exemple, si votre interpréteur est écrit en code machine x86, il obtiendrait le caractère du programme Kipple par caractère à partir du clavier, et continuerait jusqu'à ce que esc(ou toute autre touche autre qui n'émet pas de caractère imprimable) soit enfoncée.

• S'il y a une erreur, par exemple une erreur de syntaxe ou un débordement de pile, il doit le reconnaître d'une manière ou d'une autre, par exemple en renvoyant 10 au lieu de 0 ou des messages d'erreur produits par l'interpréteur / compilateur, MAIS PAS D'IMPRESSION DE MESSAGES D'ERREUR .

• Toute autre règle régulière pour le golf de code s'applique à ce défi.

• Votre code sera testé avec certains des exemples dans l'archive d' exemples de Kipple

Ceci est un code-golf . Le code le plus court en octets gagnera. Bonne chance!

Notez qu'il y a un opérateur optionnel dans Kipple, "mais il ne fait pas partie de la spécification et juste une fonctionnalité supplémentaire dans l'interpréteur officiel. Je ne l'ai pas mentionné ici, il n'a donc pas besoin d'être soutenu dans votre soumission.

Si vous avez un doute sur une partie de la spécification, vous pouvez l'examiner avec un interpréteur officiel écrit en Java . Cela téléchargera un fichier zip contenant le programme compilé et le code source. Il est sous licence GPL.

C, 709 702 octets

Le score d'octets est avec les sauts de ligne (qui peuvent être supprimés) supprimés, mais pour faciliter la lecture, je le poste ici avec les sauts de ligne:

#define R return
#define C ;break;case
c[999]={};*P=c;*S[28];M[99999]={};t;*T;
u(s,v){S[s]+=28;*S[s]=v;
if(s>26){for(t=v/10;t;t/=10)S[s]+=28;T=S[s];do{*T=48+v%10;T-=28;}while(v/=10);}}
o(s){t=S[s]-M>27;S[s]-=28*t;R S[s][28]*t;}
I(s){R s<65?27:s-97;}
O(int*p){if(!isdigit(*p))R o(I(*p));
for(;isdigit(p[-1]);--p);for(t=0;isdigit(*p);t*=10,t+=*p++-48);R t;}

main(i,a){for(i=0;i<28;++i)S[i]=M+i;
for(;~(*++P=getchar()););P=c+1;
for(;;){i=I(P[-1]);switch(*P++){
case 35:for(;*P++!=10;)
C'<':u(i,O(P))
C'>':u(I(*P),O(P-2))
C'+':u(i,*S[i]+O(P))
C'-':u(i,*S[i]-O(P))
C'?':if(!*S[i])S[i]=M+i
C'(':for(i=1,T=P;i;++T)i+=(*T==40)-(*T==41);if(S[I(*P)]-M<28)P=T;else u(26,P-c)
C')':P=c+o(26)-1
C-1:for(;i=o(14);)putchar(i); R 0;}}}

Compilez avec gcc -w golf.c(fait -wtaire les avertissements pour votre santé mentale).

Prend en charge tout sauf l' ientrée, car le demandeur n'a pas encore répondu à ma demande sur la façon de le faire si vous prenez le code de stdin. Il ne signale pas les erreurs de syntaxe.

Ruby, 718 octets (actuellement non compétitif)

Je suis très fatigué

Le fichier est chargé comme argument de ligne de commande et l'entrée est envoyée via STDIN. Alternativement, canalisez le fichier dans STDIN si vous n'avez pas besoin d'entrée dans votrei registre.

En raison d'une certaine confusion concernant la spécification, la version actuelle ne se gère pas a<b>ccorrectement et n'est donc pas compétitive jusqu'à ce qu'elle soit corrigée.

a<b>cest corrigé maintenant. Cependant, il retourne toujours le mauvais résultat lors de l'exécution de la fonction primes, il reste donc comme une réponse non compétitive.

(f=$<.read.gsub(/#.*?\n|\s[^+-<>#()?]*\s/m,' ').tr ?@,?`
t=Array.new(27){[]}
t[9]=STDIN.read.bytes
k=s=2**32-1
r=->c{c=c[0];c[0]==?(?(s[c[1..-2]]while[]!=t[c[1].ord-96]):(c=c.sub(/^(.)<(\D)>(.)/){$1+"<#{t[$2.ord-96].pop||0}>"+$3}.sub(/(\d+|.)(\W)(\d+|.)?/){_,x,y,z=*$~
a=x.ord-96
b=(z||?|).ord-96
q=->i,j=z{j[/\d/]?j.to_i: (t[i]||[]).pop||0}
l=t[a]
y<?-?(x==z ?l[-1]*=2:l<<(l.pop||0)+q[b]
l[-1]-=k while l[-1]>k/2):y<?.?(x==z ?l[-1]=0:l<<(l.pop||0)-q[b]
l[-1]+=k while l[-1]<-k/2-1):y<?>?t[a]+=a<1?q[b].to_s.bytes: [q[b]]:y<???
(t[b]+=b<1?q[a,x].to_s.bytes: [q[a,x]]): l[-1]==0?t[a]=[]:0
z||x}while c !~/^(\d+|.)$/)}
s=->c{(z=c.scan(/(\((\g<1>|\s)+\)|[^()\s]+)/m)).map &r}
s[f]
$><<t[15].reverse.map(&:chr)*'')rescue 0