Code-Bowling

Brunswick Bowling vous a embauché pour créer un programme simple permettant d'afficher le texte Code Bowlingsur ses moniteurs. Cette entreprise vaut un joli penny et vous sentez que vous pouvez les arnaquer pour un peu d'argent.

La description de poste indique clairement qu'ils paient sur une base de pointage et vous êtes persuadé que vous pouvez manipuler leur système de pointage à votre avantage et obtenir le plus gros chèque de paie possible de ces types. Pour ce faire, vous devrez insérer le plus de code possible dans votre programme / fonction, même si son système de notation est conçu pour vous empêcher de le faire.

Sortez vos tirelires, codons!

Défi

Le défi consiste simplement à sortir le texte Code Bowling, exactement comme il est écrit ici, avec le score le plus élevé possible. (Voir la section: Système de notation ci-dessous)

Les nouvelles lignes (début et fin de ligne) sont acceptables.

Votre code peut être un programme entier ou juste une fonction exécutable.

Règles

Obligatoire: Ce défi utilise Code-Bowling: Common Rules, Revision 1.0.0 ; Voir Meta pour plus de détails.

1. Caractère: Ratio d'octets
   Dans Code-Bowling, un nombre de caractères est préférable à un nombre d'octets. La raison en est évidente: les caractères unicode multi-octets (par exemple) peuvent être utilisés à la place des caractères unicode à un octet pour donner un nombre d'octets plus élevé et permettre au bowling de savoir qui renomme le plus de variables avec des caractères unicode à octets élevés que qui crée le plus stratégiquement un code complexe significatif.

2. Noms de variable / fonction / objet
   Tous les noms de variable (ou pointeurs d'objet, noms de fonction, etc.) doivent comporter 1 caractère. Le seul moment acceptable pour utiliser des noms de variables à 2 caractères est après utilisation de toutes les variables possibles à 1 caractère. Le seul moment acceptable pour utiliser des noms de variables à 3 caractères est une fois que toutes les variables à 2 caractères possibles ont été utilisées. Etc.

3. Code non utilisé
   Tout le code doit être utilisé. Cela signifie que le programme ne doit pas toujours terminer correctement la tâche si un caractère individuel (ou un ou plusieurs jeux de caractères) est / sont supprimés. Bien entendu, un sous-ensemble du programme ne devrait pas être en mesure de mener à bien la tâche sans le reste du programme.

4. Commentaires Les
   commentaires ne sont pas autorisés pour le décompte des caractères, à moins que ceux-ci ne soient utilisés par votre programme / fonction.

Système de notation:

  Défi Pangram:

Un pangramme est une phrase qui utilise chaque lettre au moins une fois. (Le renard brun rapide saute par-dessus le chien paresseux).

Ce type de défi a un système de score conçu dans lequel un pangram parfait atteindrait le score maximum théorique (bien que vous ne soyez pas obligé d'utiliser chaque personnage au moins une fois.) De plus, l'utilisation de tout caractère plus d'une fois entraînera une pénalité. Ce défi ne concerne pas uniquement les caractères alphabétiques.

  Mesure métrique:

1. Chaque personnage utilisé augmente votre score de 1.
2. L'utilisation répétée de tout caractère alphanumérique (az, AZ, 0-9) entraînera une déduction de 3 points par répétition (la première utilisation ne donne pas lieu à une déduction).
3. L'utilisation répétée de la ponctuation de base ([!?.-,":';])- y compris les crochets - donnera lieu à une déduction de 2 points par répétition.
4. L'utilisation répétée d'autres caractères ASCII {`~@#$%^&*_+=|\/><}- y compris les accolades - entraînera une déduction de 4 points par répétition.
5. L'utilisation d'espaces, de tabulations et de nouvelles lignes entraîne une déduction de 1 point par utilisation. C'est-à-dire qu'ils ne comptent pas dans le total des personnages.
6. Les caractères non mentionnés ci-dessus (caractères exotiques) entraînent une déduction de 1 point par utilisation. C'est-à-dire qu'ils ne comptent pas dans le total des personnages.

  Outil de notation:

Un widget de scoring automatisé a été créé et peut être trouvé ici .

Ceci est une variante code-bowling . Le programme avec le score le plus élevé gagne! (Puisqu'il y a un score maximum de 94, celui qui l'atteint le premier (s'il peut être atteint) sera marqué comme la réponse acceptée, même si les autres sont libres de continuer à répondre pour le plaisir)

Glypho , 94

Le fichier source est codé en CP437 .

␀␀!"☺☺#$☻♥♥☻♦♣♦♣%♠♠&•◘•◘'○○(◙♂◙♂♀♪♪♀♫☼♫☼►◄◄►↕↕)*‼¶¶‼§§+,▬↨↨▬↑↓↑↓→←→←∟∟-.↔▲▲↔/▼▼▼⌂Ç⌂Çüééüââ01ää23àååàçêçê4ëë5èïèïîî67ìÄÄì8ÅÅ9ÉÉ:;æÆÆæô<=ôöòòöûùûù>ÿÿÿÖÖ?@ÜÜAB¢££¢¥₧¥₧CƒƒDáíáíóóEFúññúѪѪGººHI¿¿J⌐¬⌐¬K½½½¼¼LM¡««¡N»»»░░OP▒▒QR▓││▓┤╡┤╡S╢╢T╖╕╖╕U╣╣V║╗║╗╝╜╜╝W╛╛╛┐X┐┐Y└└└┴┬┴┬├─├─Z┼┼┼╞╞[\╟╟]^╚╔╔╚╩╦╩╦_╠╠`═╬═╬╧╨╨╧╤╥╥╤a╙╙╙╘╘bc╒╒de╓╓fg╫╪╪╫┘┌┌┘█▄█▄▌hi▌▐j▐▐▀αα▀ßΓßΓπΣπΣkσσσµlµµτmnτΦΘΘΦΩδΩδo∞∞∞φpφφεεqr∩≡≡∩±±st≥≤≤≥u⌠⌠⌠⌡⌡vw÷xy÷≈°°≈∙∙z{·|}·√ⁿⁿ√~²²²

Essayez-le en ligne!

Explication

Glypho est très utile pour des défis comme celui-ci, car il ne se soucie pas du tout des personnages utilisés. Au lieu de cela, il regarde chaque bloc de 4 caractères et la commande utilisée est déterminée par le motif que ces quatre caractères créent:

0000 n
0001 i
0010 >
0011 \
0012 1
0100 <
0101 d
0102 [
0110 +
0111 o
0112 *
0120 -
0121 ]
0122 !
0123 e

Cela signifie que nous pouvons simplement résoudre le problème et insérer ensuite des caractères uniques dans chaque quartet avec les caractères imprimables et tous les caractères répétés avec certains des caractères "exotiques", qui sont ignorés par la notation. Glypho est suffisamment détaillé pour qu'une solution manuscrite normale contienne suffisamment de caractères uniques pour contenir les 94 caractères imprimables qu'il contient. En fait, j’ai fini par jouer jusqu’à atteindre exactement 94, juste pour pouvoir utiliser des caractères exotiques uniques pour ceux qui se répètent (espérons-le, pour rendre plus difficile la réduction du programme).

La forme abrégée du programme ci-dessus est la suivante:

11+d*d*d+d+1+1+dd1+o
d+11+d*d1+*1+-+do
11+d*d1+d**do
1+o
11+d*d*d+o
<o
ddo
11+d*d++o
111++d-<+ddo
<-+do
<1+1+o
1-+1-+o

Où chaque ligne imprime un des caractères.

J'ai utilisé ce script Retina pour le convertir en Glypho 0123. Ensuite, je viens de remplir les caractères à la place des chiffres.

En théorie, il serait peut-être possible de réduire cela davantage, si quelqu'un réussissait à jouer avec le programme de raccourci, puis à recombiner les personnages de manière à ce que les bons modèles apparaissent, mais je ne suis pas sûr de savoir comment prouver ou d'infirmer que c'est possible. . Si quelqu'un parvient à former une solution valide à partir d'un sous-ensemble de mon programme, merci de me le faire savoir afin que je puisse supprimer la réponse jusqu'à ce qu'elle soit corrigée. Jusque-là, je dois supposer que cela est valide.

Python 3, 82 87 88

Merci à @JonathanAllan pour +1 point

print("g!#$%&'*n+,./012i34579;<l=>?@ADEwFGHIJKLoMNOPQRSBTUVWXYZ ^_`abchejkmqsuvdyz{|}~ \x6f       C"[::-8])

Essayez-le en ligne!

Rien de spécial, juste trancher et sauter des caractères. La chaîne est inversée, vous ne pouvez donc pas supprimer les caractères et imprimer la chaîne d'origine.

> <> , 92 94

Oui, je l'ai fait!

␑est le caractère exotique\x11 avec la valeur décimale 17. Le programme se ferme avec une erreur après l’impression du résultat (c’est un dépassement de pile). Je devais gérer les miroirs et les commandes directionnelles que j’utilisais avec précaution, car je ne peux les utiliser qu’une seule fois.

   >"vCoUV␑3`h]Z_X
       /a[f+
#$%&'r(!
.0456~8?
:;<=@9l)
ABDEFcGe
HIJKL*
MNOPQ7
RSTWYd
bgijk1
mnqst-
uwxyz2
{|}  ,
     \p^

Essayez-le en ligne

Le programme de base:

   >"vCoUV␑3`h]Z_X
       /a[f+
     r !
     ~ ?
     9 )
     c e
     *
     7
     d
     1
     -
     2
     ,
     \p^

Explication:

Poussez la chaîne vCoUV␑3`h]Z_X >(wraps d'exécution). Déplacer vers le bas. Inversez la pile et retirez le v.

Poussez 9et c(12). Multipliez pour obtenir 108( l). Poussez 7. Appuyez sur d(13), soustrayez 1, divisez par 2pour obtenir 6. Mettez là (x, y) de (13,6), qui est en dessous de la e. J'aurais pu le faire de manière plus courte, mais ceci est allongé, ce qui me permet de mettre plus de caractères ASCII.

Montez dans une boucle. Poussez la longueur de la pile avec l. Si le nombre de caractères est supérieur à 14, créez une nouvelle pile avec les 10 meilleurs éléments, ajoutez 15, puis reflétez l'exécution, puis montez et sortez. Ceci est utilisé pour empêcher les espaces en trop et >d'être imprimés à la fin, ainsi que pour transformer la chaîne d'aspect aléatoire en ce qui doit être imprimé. Continuer en boucle.

Si l'une des lignes est plus courte (en supprimant un caractère), le programme ne fonctionnera plus, soit parce que les parties verticales du programme ne s'alignent plus, soit parce que la chaîne à imprimer n'est plus correcte. Tenter de supprimer un caractère situé devant chaque ligne modifiera la profondeur de la pile et l'emplacement de la l, ce qui causera également des problèmes.

^_Poisson

Octave, 20 21 22 25 27 33

Le mieux que j'ai réussi jusqu'ici est

g=@()disp(horzcat([67 9583 -412],'e B',"nvkhmf"+!0));

Cela crée une fonction anonyme fqui ne prend aucune entrée. Vous pouvez l'appeler f(). Je dirais que le point-virgule à la fin est nécessaire, afin d'éviter l'impression du corps de la fonction.

Il est possible que cela puisse être amélioré en combinant evalet printf, mais j'ai essayé et échoué encore et encore.

Cela utilise tous les chiffres une fois, en expliquant le fait qu'Octave effectue une mod(x,256)opération lors de la conversion implicite de nombres en caractères. Cela signifie que nous pouvons utiliser des nombres négatifs, ainsi que des nombres situés en dehors de la 32-126plage normale . Les numéros suivants tout résultat dans la lettre ilorsqu'il est converti en caractères: ... -2455 -2199 -1943 ... 105 361 .... Au lieu d'utiliser 'owling'finalement, nous utilisons "nvkhmf"et ajoutons 1. Cela crée un vecteur d'entiers qui sont implicitement convertis en caractères. Au lieu de 1, nous utilisons !0(ou not(false). En outre, nous utilisons "au lieu de 'éviter deux points de pénalité.

Nous devons trouver l'ensemble des nombres qui donne le score le plus bas. La chaîne Code Bowlingrésulte dans la matrice suivante, lorsque nous soustrayons et ajoutons -10 * 256 - 10 * 256.

  -2493  -2449  -2460  -2459  -2528  -2494  -2449  -2441  -2452  -2455  -2450  -2457
  -2237  -2193  -2204  -2203  -2272  -2238  -2193  -2185  -2196  -2199  -2194  -2201
  -1981  -1937  -1948  -1947  -2016  -1982  -1937  -1929  -1940  -1943  -1938  -1945
  -1725  -1681  -1692  -1691  -1760  -1726  -1681  -1673  -1684  -1687  -1682  -1689
  -1469  -1425  -1436  -1435  -1504  -1470  -1425  -1417  -1428  -1431  -1426  -1433
  -1213  -1169  -1180  -1179  -1248  -1214  -1169  -1161  -1172  -1175  -1170  -1177
   -957   -913   -924   -923   -992   -958   -913   -905   -916   -919   -914   -921
   -701   -657   -668   -667   -736   -702   -657   -649   -660   -663   -658   -665
   -445   -401   -412   -411   -480   -446   -401   -393   -404   -407   -402   -409
   -189   -145   -156   -155   -224   -190   -145   -137   -148   -151   -146   -153
     67    111    100    101     32     66    111    119    108    105    110    103
    323    367    356    357    288    322    367    375    364    361    366    359
    579    623    612    613    544    578    623    631    620    617    622    615
    835    879    868    869    800    834    879    887    876    873    878    871
   1091   1135   1124   1125   1056   1090   1135   1143   1132   1129   1134   1127
   1347   1391   1380   1381   1312   1346   1391   1399   1388   1385   1390   1383
   1603   1647   1636   1637   1568   1602   1647   1655   1644   1641   1646   1639
   1859   1903   1892   1893   1824   1858   1903   1911   1900   1897   1902   1895
   2115   2159   2148   2149   2080   2114   2159   2167   2156   2153   2158   2151
   2371   2415   2404   2405   2336   2370   2415   2423   2412   2409   2414   2407
   2627   2671   2660   2661   2592   2626   2671   2679   2668   2665   2670   2663

Donc, les ['',2627 2415 2148 1893 -2528 66 -1169 -1161 2668 105 -146 103]résultats dans ans = Code Bowling. Le défi consiste alors à trouver l'ensemble des chiffres et des caractères qui réduisent le plus le score. Bien sûr, utiliser tous les chiffres est bon, mais les doublons sont mauvais. Comme tous les chiffres sont utilisés, et non sont utilisés deux fois, il s'agit du meilleur mélange possible. En outre, nous arrivons à utiliser -, résultant en un point.

On pourrait prétendre qu’elle peut être réduite à la ligne inférieure (31 points), mais alors ce ne serait plus une "fonction exécutable" et aurait donc une fonctionnalité différente.

disp(horzcat([67 9583 -412],'e B',"nvkhmf"+!0))

QBasic, 34

C'est du code non formaté (oui pour l'insensibilité à la casse). Vous pouvez l'exécuter dans QB64 ou sur archive.org ( sachez toutefois que ce dernier formatera le code au fur et à mesure que vous le tapez). Je pense avoir réussi à respecter toutes les règles.

CLS
PrINT "C
LOcatE 1, 2 : ? CHR$(957-846); "de Bowling

Le CLSest nécessaire: sans cela, l’ Cimpression n’est pas garantie dans le coin supérieur gauche de l’écran, là où il s’alignera ode Bowling. Le LOcatEnécessaire: sans cela, ode Bowlingsera imprimé sur la ligne ci-dessous C. Je ne crois pas qu'il y ait un sous-ensemble du programme (à l'exception des espaces) qui puisse être supprimé et conserve le même résultat.

C, 27 29

+2 points grâce à @ceilingcat!

f(){char q<:]="Code B\157wling";puts(q);%>

Haskell , score 21 38 46 47 21 70

putStr$toEnum(length"!#%&'*+,-./012345789;<=>?@ADGHIJKLMNOPQRTUVWXYZ[]^_`abcfjkqsvyz{|}~"):"ode B\x6Fwling"

Essayez-le en ligne! L'idée est d'obtenir le début Cen construisant une chaîne de longueur 67 qui contient tous les caractères non utilisés par ailleurs et en convertissant la longueur de cette chaîne en un caractère. J'ai commencé avec putStr$toEnum(length""):"ode B\x6Fwling"( '\x6F'c'est hexadécimal pour '\111'lequel les rendements 'o') et calculé tous les caractères imprimables ASCII non contenus dans le programme:

!#%&'*+,-./012345789;<=>?@ACDGHIJKLMNOPQRTUVWXYZ[]^_`abcfjkqsvyz{|}~

Incidemment, il reste exactement 67 caractères ASCII imprimables qui peuvent être insérés dans la chaîne et Clui - même qui ne peuvent pas figurer dans la chaîne car le programme serait alors réductible à putStr"Code B\x6Fwling".

Solution précédente: (score 21)

f|x<-'C'=mapM putStr[(:)x"ode Bowling"]

Définit une fonction fqui ne prend aucune entrée et imprime la chaîne. Essayez-le en ligne!

JavaScript, 19

prompt('C\157de B\x6fwlin'+"g")

Pas un très bon score.

Jelly , 94

“!#"$&('*)+-/,13.0456:79<;>=@B?ADFHJLNCPRTEVXZ\G^IKMQ`SWbY[]d_acfhjegliknmprotquvxwy{z}¹|³⁵⁷~°⁹⁻”O%2s8UḄỌ

Essayez-le en ligne!

105 personnages uniques, 11 exotiques ( “¹³⁵⁷°⁹⁻”ḄỌ).

Comment?

Forme la chaîne à partir d'ASCII inversé sur 8 bits, chaque bit étant codé à l'aide du LSB de la valeur Unicode d'un caractère.

“...”O%2s8UḄỌ - Main link: no arguments
“...”         - the string enclosed            !  #  "  $  &  (  '  *  )  +  -  /  ,  1  3  .  0  4  5  6  :  7  9  <  ;  >  =  @  B  ?  A  D  F  H  J  L  N  C  P  R  T  E  V  X  Z  \  G  ^  I  K  M  Q  `  S  W  b  Y  [  ]   d  _  a  c   f   h   j   e   g   l   i   k   n   m   p   r   o   t   q   u   v   x   w   y   {   z   }   ¹   |   ³    ⁵    ⁷   ~   °    ⁹    ⁻
     O        - cast to ordinal (vectorises) [33,35,34,36,38,40,39,42,41,43,45,47,44,49,51,46,48,52,53,54,58,55,57,60,59,62,61,64,66,63,65,68,70,72,74,76,78,67,80,82,84,69,86,88,90,92,71,94,73,75,77,81,96,83,87,98,89,91,93,100,95,97,99,102,104,106,101,103,108,105,107,110,109,112,114,111,116,113,117,118,120,119,121,123,122,125,185,124,179,8309,8311,126,176,8313,8315]
      %2      - mod 2 (vectorises)           [ 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1,  0, 1, 1, 1,  0,  0,  0,  1,  1,  0,  1,  1,  0,  1,  0,  0,  1,  0,  1,  1,  0,  0,  1,  1,  1,  0,  1,  1,  0,  1,   1,   1,  0,  0,   1,   1]
        s8    - split into chunks of 8       [[1,1,0,0,0,0,1,0], [1,1,1,1,0,1,1,0], [0,0,1,0,0,1,1,0], [1,0,1,0,0,1,1,0], [0,0,0,0,0,1,0,0], [0,1,0,0,0,0,1,0], [1,1,1,1,0,1,1,0], [1,1,1,0,1,1,1,0], [0,0,1,1,0,1,1,0], [1,0,0,1,0,1,1,0], [0,1,1,1,0,1,1,0], [1,1,1,0,0,1,1]]
          U   - upend (vectorises)           [[0,1,0,0,0,0,1,1], [0,1,1,0,1,1,1,1], [0,1,1,0,0,1,0,0], [0,1,1,0,0,1,0,1], [0,0,1,0,0,0,0,0], [0,1,0,0,0,0,1,0], [0,1,1,0,1,1,1,1], [0,1,1,1,0,1,1,1], [0,1,1,0,1,1,0,0], [0,1,1,0,1,0,0,1], [0,1,1,0,1,1,1,0], [1,1,0,0,1,1,1]]
           Ḅ  - binary to int (vectorises)   [67, 111, 100, 101, 32, 66, 111, 119, 108, 105, 110, 103]
            Ọ - to character (vectorises)    ['C', 'o', 'd', 'e', ' ', 'B', 'o', 'w', 'l', 'i', 'n', 'g']
              - implicit print               Code Bowling

Röda , 33 ans

{["ode B\x6fwling"]|push chr(3*4+57-2).._}

Essayez-le en ligne!

J'ai essayé de suivre toutes les règles. Cela fonctionne en poussant d'abord la chaîne ode Bowling!dans le flux, puis en insérant C= 3 * 4 + 57-2 au premier plan.

Cardinal 20

23 caractères non blancs
% #> / NI "CodeB8 ^ o) wl, ing

-3 pour répété "o"

   I
 >\/N
%# "CodeB
 8^o
 ) w
   l
 , i
   n
   g

Chemins de pointeur:

Étape 1: le
pointeur créé à% va à droite

Étape 2: Le
pointeur se sépare en # pour monter, à droite et en bas (P1, P2, P3)

Étape 3 :
P1 envoyé directement par>
P2 Aller à droite
P3 Définir attendre 3 étapes à 8h

Étape 4:
P1 réfléchi par \. \ changé en /
P2 Définit le mode d'impression par "
P3 Attend 2 ticks à 8

Étape 5:
P1 En descendant
P2 Imprimer C
P3 Attendre 1 tick à 8

Étape 6:
P1 Envoyé par ^
P2 Imprimer o
P3 Terminer attendre, continuer, extraire la valeur ASCII de "" (32) à partir de)

Étape 7: P1 En haut
P2 Imprimer d
P3 En bas

Étape 8: P1 reflète le droit de \ modifié en /
P2 Print e
P3 Caractère d’impression avec une valeur ASCII = 32 à partir de, opération

Étape 9:
P1 Reflété par / qui est changé en \
P2 Imprimer B
P3 Fin de champ atteinte et arrête

Étape 10:
P1 réfléchi par I
P2 Fin de champ atteinte et arrêts

Étape 11:
P1 Reflète juste par / qui a été changé en \. Retour à /

Étape 12:
P1 réfléchi à gauche par N

Étape 13:
P1 réfléchi par /

Étape 14:
P1 Définissez le mode d'impression par "

Étape 15:
Impression P1 o

Étape 16:
Impression P1 avec w

Étape 17:
Impression P1 l

Étape 18:
Impression P1 i

Étape 19:
Impression P1 n

Étape 20:
Impression P1 g

Étape 21:
P1 Atteint la fin du champ et s’arrête.

Essayez-le en ligne

C, 73

Merci à @Laikoni!

F(){printf("Code B\157wli%cg",48+strlen("!#$&'*-../2369:<=>?@ADEGHIJKLMNOPQRSTUVWXYZ[]^_`abhjkmquvxyz|~"));}

Essayez-le en ligne!

C,  31   33  35

F(){printf("Code B\157wli%cg",96|0xD+3*4/8);}

Merci à @ceilingcat et @DLosc pour deux points supplémentaires et à @ Ørjan Johansen pour deux autres points!

Essayez-le en ligne!

Lot, 19 caractères

@echO(Cod%TMP:~5,1% Bowling

Commençant par Windows Vista, TMPcommence par C:\Users\et constitue donc %TMP:~5,1%une manière verbeuse d’écrire e, même s’il faut imposer une %pénalité double à -4.

Brainfuck: -204

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

Bien, score épouvantable, mais c'était amusant à écrire.

• 122 caractères
• alnum répété: -0 ()
• ponctuation répétée: -134 (- [---]. ----------- ..-- [---] -. [-] .- [---] ..-- ---------. --- ..-------.)
• répété autre: -192 (+++++++> +> + <> ++++> + <> +> ++ <>> + <> +++++++++++++ ++++)
• caractères d'espacement: -0 ()
• personnages exotiques: -0 ()

Java 8, 2 3 5 13 17 18 19 20 21 24 77 78 points

+53 score (24 → 77) grâce à @Laikoni .

v->(char)"!#$%&'*,/0234689:;<=?@ADEFGHIJKLMNOPQRSTUVWXYZ[]^_`bfjkmpqsuxyz{|}~".length()+"\157de Bowling"

104 caractères
- alnum répété: -15 ( helng)
- ponctuation répétée: -10 ( "()"")
- autre ASCII répété: aucun
- caractères d'espacement: -1
SCORE: 78

Essayez-le en ligne.

Vieux 24 octets répondent:

v->"C\157de Bowlin"+(char)103;

30 caractères
- alnum répété: -3 ( 1)
- ponctuation répétée: -2 ( ")
- autre ASCII répété: aucun
- caractères d'espacement: -1
SCORE: 24

Essayez-le en ligne.

empilés , 42

(67:43,1 ab)2 9*pf sum 8/0\|>+chr'de Bowling',EPS#`

Essayez-le en ligne!

Laisse la sortie sur la pile. Voici la ventilation:

length: 51
repeated alnum:        -0 ()
repeated punct:        -4 (',)
repeated other:        -0 ()
whitespace characters: -5 (     )
exotic characters:     -0 ()
total score: 42

Je pourrais probablement le faire plus haut, mais il est à 42 soo ....

Un autre concurrent, 40:

(67:43,sum)9 pf 2%MIN 0\|>+chr'de Bowling',EPS#`

J'ai utilisé ce script pour le marquer.

le mal , -81

Mieux que Brainfuck!

aeeaeuwkaaeeuwygaeaeclaaxjlwalusbdgueuewguwpweewpuuuwuuuwpuweew

Explication

aeeaeuw //Write 'C'
k       //Set P[0] to 'C'
aaeeuw  //Write 'O'
y       //Set W[0] to 'O'
gaeae   //Set Accumulator to 'D'
claa    //Create new Wheel cell at index 0, swap with Accumulator, add 2
xj      //Set alternate marker mode and drop marker
lwa     //Write value of W[0], add 1
lu      //Put it back, subtract 1 from Accumulator
sb      //Go to 'j' if Accumulator != 0
d       //Delete W[0]
        //The above loop writes 'D' and 'E'
gueuew  //Write ' '
guw     //Write 'B'
pw      //Write 'o'
eew     //Write 'w'
puuuw   //Write 'l'
uuuw    //Write 'i'
puw     //Write 'n'
eew     //Write 'g'

Soumis parce que personne ne fait rien dans le mal mais c'est assez amusant.

But:

Longueur = 63

a*8  = -24
e*12 = -36
g*2  = -6
l*2  = -6
p*2  = -6
u*12  = -36
w*10  = -30

Essayez-le en ligne!

EDIT: TiO semble gérer de manière incorrecte la création et la suppression de nouvelles cellules Wheel - J'ai déposé un rapport de bogue sur le sujet. Cela ne fonctionnera pas correctement là-bas, mais je l'ai exécuté sur mon propre interprète et cela fonctionne et vous pouvez vous fier à moi pour que je ne m'inquiète pas pour ça;)

Perl: 29 , 33

$_=OWLING;printf%s,"C\157de".chr(30+8/4).B.lc

But:

- 46 characters long
- repeated alnum:       -6 (rc)
- repeated punctuation: -6 ("..)
- repeated other:       -0 ()
- whitespace characters:  -1 (
)
- exotic characters:  -0 ()

Total score: 33

05AB1E , 94 points

”X1234bcde5fghijk68l9<mn>,o.p|q\/{})r(_-+s=tu*vwxyzAB&YDEFG^HI%$ZK#L@!MNO~PQR`ST':UVW[0];"”€a7ôJCç€?

Essayez-le en ligne!

- 100 characters long
- repeated alnum:       -0 ()
- repeated punctuation: -0 ()
- repeated other:       -0 ()
- whitespace characters:  -0 ()
- exotic characters:  -6 (””€ôç€)

Total score: 94

Convertit essentiellement (l'ASCII binaire de Code Bowling):

['1000011', '1101111', '1100100', '1100101', '0100000', '1000010', '1101111', '1110111', '1101100', '1101001', '1101110', '1100111']

Dans une chaîne de 1 et de 0, chaque 1 est remplacé par une lettre de l'alphabet et chaque 0 par un espace, un symbole ou un chiffre.

”X1234bcde5fghijk68l9<mn>,o.p|q\/{})r(_-+s=tu*vwxyzAB&YDEFG^HI%$ZK#L@!MNO~PQR`ST':UVW[0];"”

Est la chaîne, où 1 sont des lettres et 0 sont des symboles, des chiffres ou toute autre chose. Nous parcourons ensuite, en voyant lesquels sont alphabétiques, en poussant 1 pour alphabétique 0 pour non alphabétique. Nous divisons ensuite en groupes de 7, reconvertissons en ASCII et imprimons chaque caractère.

T-SQL, 65 18 32! points

PRINT char(78-9605*43%12) + 'ode Bowling'

Inspiré par une astuce de la réponse QBasic de Dlosc , j'ai trouvé un moyen d'inclure les 10 chiffres et la plupart des opérateurs mathématiques ( %reste / modulo, manquant seulement /), principalement par essais et erreurs. Je ne pense pas qu'il soit possible d'obtenir un 67 en supprimant une combinaison de chiffres / symboles, mais vous pouvez essayer.

Version 2 (18 points, trivial):

DECLARE @ char(12)='Code Bowling'PRINT @

Pas un très bon score, mais c’est ce que ma première version a simplifié (merci, MickyT). Tout le reste que j'ai essayé (encodage et décodage de hex64, sélection d'éléments individuels dans une chaîne, conversion de valeurs ASCII, etc.) comportait trop de caractères répétés (en particulier des ECRsymboles (),@) qui le conduisaient au négatif.

Version 1 (65 points, invalide):

DECLARE @ char(123)=
'Code Bowling FGHJKMOQSUVWXYZbjkmpqsuvxyz045789 [!?.-":;]{`~#$%^&*_+|\><}'
PRINT left(@,LEN(@)/6)

J'ai utilisé la longueur de la chaîne pour déterminer le nombre de caractères que j'utilise du côté gauche. Par conséquent, si vous supprimez un seul caractère de la chaîne, le résultat de la division entière sera abaissé à 11, en sortie uniquement Code Bowlin.

; # , score -1163, non compétitif

Je ne pense pas que ce serait beaucoup de concurrence même si cela pouvait rivaliser.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#

Essayez-le en ligne! Remarque: TIO n'a pas; # d'interprète, seulement; # +.

CJam , score 47

"'#?GyQ2wE(s6&␟JI!gF$u*Aq;0p4BvOKkHLhM"3/{:i~-z+c}%

Espérons que cela ne pose aucun problème ...

Utilise un caractère exotique (séparateur d'unité, ASCII 31, représenté par ␟) et un caractère répété ( "). Je pense que cela pourrait être encore plus long, mais je vais le laisser tel quel pour le moment.

Essayez-le en ligne!

Le programme fonctionne en prenant cette longue chaîne et en la divisant en sous-chaînes de longueur 3. Chaque sous-chaîne est ensuite mappée sur le bloc, ce qui convertit ses caractères en leurs valeurs ASCII, vide les valeurs de la pile, prend la différence absolue des deux secondes, ajoute le résultat avec le premier, puis reconvertit le résultat final en ASCII. personnage.

CJam, score 93

"g!#$&'()n*+/0134i5689:;<l=>?@ADEwFGHIJKLoMNOPQRSBTUVWXYZ [\]^_`aebcfhjkmdqrstuvxpyz{|}  C"7~%2,.-

Essayez-le en ligne

Inspiré de la réponse Python de TidB .
Je ne sais pas s’il est possible d’éviter la répétition des guillemets.

Explication:

La chaîne contient "Cpde Bowling" en sens inverse, tous les 8 caractères.
7~%extraits "Cpde Bowling" ( 7~= -8)
2,.-décrémente le caractère p ( 2,= [0 1])

PHP, 33 points

C'était assez difficile à trouver.

Le score pourrait être amélioré à l'avenir.

<?echo IHASZODECG9F^"
'%6z\r+2/.W!";

La nouvelle ligne est supposée être une nouvelle ligne de style Linux! Le style Windows et le style Mac ancien ne fonctionneront pas correctement.

Ruby, 75

Approximativement un port de la réponse Python, mais Ruby n’a pas cette fonction step cool, alors j’utilise gsubplutôt. J'ai aussi décidé de m'amuser un peu avec les personnages exotiques en lançant des phrases dans Google Translate

Essayez-le en ligne!

print"Cachjkmq\x6fvyzADEFdGHIJKLMeNOPQRST UVWXYZ0B234589[o!?-:;]`w~@\#$%^&l*_+=|><i コードゴルフn 代碼保齡球 gκωδικός".gsub /(.).{7}/,'\1'

USML, 12 ou 9 points (non en compétition)

"Code\tBowling'

Essayez-le en ligne!

Cette réponse trompe un peu en abusant du rendu HTML. La chaîne réellement créée par ceci est "Code\tBowling ". Des points sont perdus pour avoir répété le caractère "o".

Pour une réponse non trompeuse:

"Code Bowling

USML en est encore à ses débuts et n’est pas encore en mesure d’augmenter la taille du programme.

Cubix , 85

Codeha1spqumtr;$"gnilwoB"Sv"ADEFH%IJK2f!OPUzQ0V3XY&*[-|L:]\T`~#x>MR56cGk'?W<()b4j}.{Z_^/978@

Essayez-le en ligne!

Cubifié avec des caractères insignifiants remplacés par.

        C o d e
        . . . .
        . . u . 
        . . ; . 
" g n i l w o B " S v " . . . .
. . . . . . . ! . . U . . . . .
. . . . . . . L . . \ . . . . .
> . R . . . . . . . W < . . . .
        . . . {
        . . ^ /
        . . . @
        . . . .

Je pense avoir rendu le chemin assez fragile pour que le retrait de personnages le casse.

Regarde le courir

- 92 characters long
- repeated alnum:       -3 (o)
- repeated punctuation: -4 ("")
- repeated other:       -0 ()
- whitespace characters:  -0 ()
- exotic characters:  -0 ()

Total score: 85

VB.net, 68

cONSOLE.WRITE("Code BowlingADEFGHJKQUVXYZfhjkmpqyz`!@#$%^&*9876543~][{}\|';:<>?+=-_".subStrinG(0,12))

Un test rapide mettant à profit l'insensibilité à la casse et le manque de "système" de VB.

Coquille: note 17

#!/bin/bash
echo "CODE BoWLING" | tr D-X d-x

• 44 caractères
• alnum répété: -12 (bhoD)
• ponctuation répétée: -4 ("-)
• répété autre: -4 (/)
• caractères d'espacement: -7 ()
• personnages exotiques: -0 ()

Score total: 17

Acc !! , 171 caractères

119
Write _-52
Write _-8
Count i while i-2 {
	Write _-19+i
}
32
Write _
_+34
Write _
_+45
Write _
_+8
Write _
_-11
Write _
Count i while i-2 {
	Write 105+i*5
}
_-5
Write _

Essayez-le en ligne!

Acc !! fonctionne bien pour ce défi car les espaces sont nécessaires et les boucles sont coûteuses. Je me suis servi de l’ accumulateur ici, mais mal, pour augmenter les caractères. Voici un bref aperçu de la page:

AccumulatorToute expression autonome est évaluée et attribuée à l'accumulateur (qui est accessible en tant que _). Ainsi, par exemple, 3 est une déclaration qui définit l'accumulateur sur 3; _ + 1 incrémente l'accumulateur; et _ * N lit un caractère et multiplie l'accumulateur par son charcode. (N obtient l'entrée)

Write <charcode> Renvoie un seul caractère avec la valeur ASCII / Unicode donnée sur stdout. Le charcode peut être n'importe quelle expression.

Les boucles en Acc, du moins pour le golf, sont pénibles. Ils ont besoin d'accolades et tous les espaces sont nécessaires. Sinon, c'est assez explicite.