ALGORITHMEN - Teil XXV: Das Fleisch ist willig, aber der Geist ist schwach...

    Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

    Unsere Datenschutzerklärung wurde aktualisiert. Mit der Nutzung unseres Forums akzeptierst Du unsere Datenschutzerklärung. Du bestätigst zudem, dass Du mindestens 16 Jahre alt bist.

    • ALGORITHMEN - Teil XXV: Das Fleisch ist willig, aber der Geist ist schwach...

      Hier kann jeder machen was er will - ob er will oder nicht! :8O:
      Win7-64HomPremSP1,XProfan11.2a,XPIA,JWasm,xpse,IntelCoreQuad2.5GHz/4GB/je1TB HD intern:esataBay:USB3
    • Abt. ´ISAAC´- ein Crypto-geeigneter Pseudo-Zufallsgenerator
      =======================================
      Auf den Seiten von ´Rosetta Code´ werden Standardaufgaben der Informatik in den unterschiedlichsten Programmiersprachen gelöst. Anbei eine Umsetzung der sog. ISAAC-Cypher in XProfan 11.2a-free, in Anlehnung an eine PASCAL-Musterlösung in Public Domain. Dazu musste allerdings der mod-Operator von XProfan durch eine Floating-Point-Funktion ersetzt werden.
      Gruss

      Brainfuck-Quellcode

      1. WindowTitle "PROGRAM RosettaISAAC V2.2-beta"
      2. '(PD) Public Domain, transposed to XProfan-11.2a in
      3. 'Feb. 2020 by P.Specht(AT)gmx.at, Vienna/Austria/EU
      4. '-----------------------------------------------------------------------------
      5. '[The Improved] Random Number Generator ISAAC (C) by Bob Jenkins,
      6. ' March 1996, Public Domain, C-Source Intro: "You may use this code in any way
      7. ' you wish, and it is free. No warrantee."
      8. '-----------------------------------------------------------------------------
      9. '[Rosetta Text:] ISAAC stands for "Indirection, Shift, Accumulate, Add, and Count"
      10. 'which are the principal bitwise operations employed. To date - after 24 years of
      11. 'existence ISAAC has not been broken (unless GCHQ or NSA did it, but dont tell us).
      12. 'ISAAC thus deserves a lot more attention than it has received, and it would be
      13. 'salutary to see it more universally implemented.
      14. '-----------------------------------------------------------------------------
      15. GOTO "FloatMaths" // uses MODf() on uInt instead of XProfan's MOD Operator
      16. START:
      17. CLS
      18. Var iMode&=0
      19. Def &iEncrypt 0
      20. Def &iDecrypt 1
      21. Def &true 1
      22. Def &false 0
      23. // TASK globals
      24. Var msg$ = "a Top Secret secret" // Recommended max 4095 Byte
      25. var key$ = "this is my secret key" // Max. 256 Byte are used
      26. // Main Globals
      27. var xctx$ = "" // XOR ciphertext
      28. var mctx$ = "" // MOD ciphertext
      29. var xptx$ = "" // XOR decryption (plaintext)
      30. var mptx$ = "" // MOD decryption (plaintext)
      31. // ISAAC vars have to be globals in XProfan:
      32. // external results
      33. declare randrsl&[255]
      34. declare randcnt&
      35. // internal state
      36. declare mm&[255]
      37. declare aa&,bb&,cc&
      38. // inter proc
      39. declare a&,b&,c&,d&,e&,f&,g&,h&
      40. PROC ISAAC // PSEUDO RANDOM GENERATOR
      41. 'If the initial internal state is all zero, after ten calls the values of
      42. 'aa, bb, and cc in hexadecimal will be d4d3f473, 902c0691, and 0000000a.
      43. declare i&,x&,y&
      44. inc cc& // cc just gets incremented once per 256 results
      45. inc bb&,cc& // then combined with bb
      46. Whileloop 0,255:i&=&Loop
      47. x&=mm&[i&]
      48. SELECT (i& MOD 4)
      49. caseof 0:aa&=XOR(aa&,(aa&<<13))
      50. caseof 1:aa&=XOR(aa&,(aa&>>6))
      51. caseof 2:aa&=XOR(aa&,(aa&<<2))
      52. caseof 3:aa&=XOR(aa&,(aa&>>16))
      53. ENDSELECT
      54. aa&= mm&[(i&+128) MOD 256]+aa&
      55. y&= mm&[(x&>>2) MOD 256]+aa&+bb&
      56. mm&[i&]=y&
      57. bb&=mm&[(y&>>10) MOD 256]+x&
      58. randrsl&[i&]=bb&
      59. EndWhile
      60. // Additional: prepare to use the first set of results
      61. randcnt&=0
      62. EndProc
      63. Proc Mix
      64. a&=XOR(a&,(b&<<11)):inc d&,a&:inc b&,c&
      65. b&=XOR(b&,(c&>>2)):inc e&,b&:inc c&,d&
      66. c&=XOR(c&,(d&<<8)):inc f&,c&:inc d&,e&
      67. d&=XOR(d&,(e&>>16)):inc g&,d&:inc e&,f&
      68. e&=XOR(e&,(f&<<10)):inc h&,e&:inc f&,g&
      69. f&=XOR(f&,(g&>>4)):inc a&,f&:inc g&,h&
      70. g&=XOR(g&,(h&<<8)):inc b&,g&:inc h&,a&
      71. h&=XOR(h&,(a&>>9)):inc c&,h&:inc a&,b&
      72. Endproc
      73. Proc iRandInit :parameters flag&
      74. declare i& ':init a,b,c,d,e,f,g,h 'In XProfan globaly!
      75. clear aa&,bb&,cc&
      76. a&=$9e3779b9 // the golden ratio
      77. b&=a&:c&=a&:d&=a&:e&=a&:f&=a&:g&=a&:h&=a&
      78. Whileloop 0,3 // scramble it
      79. Mix
      80. Endwhile
      81. i&=0
      82. REPEAT // fill in mm[]
      83. IF flag& // use all the information in the seed
      84. a&=a&+randrsl&[i&]
      85. b&=b&+randrsl&[i&+1]
      86. c&=c&+randrsl&[i&+2]
      87. d&=d&+randrsl&[i&+3]
      88. e&=e&+randrsl&[i&+4]
      89. f&=f&+randrsl&[i&+5]
      90. g&=g&+randrsl&[i&+6]
      91. h&=h&+randrsl&[i&+7]
      92. ENDIF
      93. Mix 'mm[] using a-h
      94. mm&[i&]=a&
      95. mm&[i&+1]=b&
      96. mm&[i&+2]=c&
      97. mm&[i&+3]=d&
      98. mm&[i&+4]=e&
      99. mm&[i&+5]=f&
      100. mm&[i&+6]=g&
      101. mm&[i&+7]=h&
      102. inc i&,8
      103. UNTIL i& > 255
      104. IF flag& // do a second pass to make all of the seed affect all of mm
      105. i&=0
      106. REPEAT
      107. a&=a&+mm&[i&]
      108. b&=b&+mm&[i&+1]
      109. c&=c&+mm&[i&+2]
      110. d&=d&+mm&[i&+3]
      111. e&=e&+mm&[i&+4]
      112. f&=f&+mm&[i&+5]
      113. g&=g&+mm&[i&+6]
      114. h&=h&+mm&[i&+7]
      115. Mix() 'mm[]
      116. mm&[i&]=a&
      117. mm&[i&+1]=b&
      118. mm&[i&+2]=c&
      119. mm&[i&+3]=d&
      120. mm&[i&+4]=e&
      121. mm&[i&+5]=f&
      122. mm&[i&+6]=g&
      123. mm&[i&+7]=h&
      124. inc i&,8
      125. UNTIL i& > 255
      126. ENDif
      127. ISAAC // fill in the first set of results
      128. randcnt&=0 // prepare to use the first set of results
      129. Endproc
      130. Proc iSeed :parameters seed$,flag&
      131. // Seed ISAAC with a given string.
      132. // The string can be any size. The first 256 values will be used.
      133. declare i&,m&
      134. mm&[]=0
      135. m&=Len(seed$)-1
      136. Whileloop 0,255:i&=&Loop
      137. // in case seed has less than 256 elements
      138. If i&>m&
      139. randrsl&[i&]=0
      140. // Pascal strings are 1-based, like in XProfan
      141. Else
      142. randrsl&[i&]=Ord(mid$(seed$,i&+1,1))
      143. Endif
      144. Endwhile
      145. // initialize ISAAC with seed
      146. iRandInit(flag&)
      147. EndProc
      148. Proc iRandom // Get a random 32-bit value 0..MAXINT
      149. declare iRandom&
      150. iRandom& = randrsl&[randcnt&]
      151. inc randcnt&
      152. IF randcnt&>255
      153. ISAAC
      154. randcnt&=0
      155. ENDif
      156. return if(iRandom&<0,iRandom&+2^32,iRandom&*1)'=float
      157. Endproc
      158. Proc iRandA // Get a random character in printable ASCII range
      159. return intf(modf(iRandom(),95)+32)
      160. ENDproc
      161. // Convert an ASCII string to a hexadecimal string
      162. Proc Ascii2Hex :parameters s$
      163. Declare i&,Ascii2Hex$
      164. Ascii2Hex$=""
      165. Whileloop len(s$):i&=&Loop
      166. Ascii2Hex$=Ascii2Hex$+Right$("0"+hex$(Ord(mid$(s$,i&,1))),2)
      167. Endwhile
      168. return Ascii2Hex$
      169. EndProc // Ascii2Hex
      170. Proc Vernam :parameters msg$
      171. // XOR encrypt on random stream. Output: ASCII string
      172. Declare i&,vernam$
      173. Vernam$=""
      174. whileloop len(msg$):i&=&Loop
      175. Vernam$=Vernam$+Chr$(xor(iRandA(),Ord(mid$(msg$,i&,1))))
      176. endwhile
      177. return vernam$
      178. Endproc // Vernam
      179. Proc LetterNum :parameters letter$,start$
      180. // Get position of the letter in chosen alphabet
      181. return Ord(letter$) - Ord(start$)
      182. Endproc // LetterNum
      183. // Caesar-shift a character <shift> places: Generalized Vigenere
      184. Proc Caesar :parameters m&,ch$,shift&,modulo&,start$
      185. Declare n&
      186. Case m& = &iDecrypt: shift& = -shift&
      187. n& = LetterNum(ch$, start$) + shift&
      188. n& = n& MOD modulo&
      189. Case n&<0:n& = n&+modulo&
      190. return Chr$(Ord(start$) + n&)
      191. Endproc // Caesar
      192. // Vigenere MOD 95 encryption & decryption. Output: ASCII string
      193. Proc Vigenere :parameters msg$,m&
      194. Declare i&,Vigenere$
      195. Vigenere$ = ""
      196. whileloop len(msg$):i&=&Loop
      197. Vigenere$ = Vigenere$ + Caesar(m&, mid$(msg$,i&,1), iRandA(), 95, " ")
      198. endwhile
      199. return Vigenere$
      200. Endproc // Vigenere
      201. BEGIN:
      202. 'Main Program
      203. // 1) seed ISAAC with the key
      204. iSeed(key$, &true)
      205. // 2) Encryption
      206. // a) XOR (Vernam)
      207. xctx$ = Vernam(msg$)
      208. // b) MOD (Vigenere)
      209. mctx$ = Vigenere(msg$, &iEncrypt)
      210. // 3) Decryption
      211. iSeed(key$, &true) // key sentence, 0=totally new 1=useAllpreviouseRandoms
      212. // a) XOR (Vernam)
      213. xptx$ = Vernam(xctx$)
      214. // b) MOD (Vigenere)
      215. mptx$ = Vigenere(mctx$, &iDecrypt)
      216. // program output
      217. Print
      218. print "Message: ", msg$
      219. print "Key : ", key$
      220. Print "XOR : ", Ascii2Hex(xctx$)
      221. Print "MOD : ", Ascii2Hex(mctx$)
      222. Print "XOR dcr: ", xptx$
      223. Print "MOD dcr: ", mptx$
      224. 'Check Output:
      225. 'Message: a Top Secret secret
      226. 'Key : this is my secret key
      227. 'XOR : 1C0636190B1260233B35125F1E1D0E2F4C5422
      228. 'MOD : 734270227D36772A783B4F2A5F206266236978
      229. 'XOR dcr: a Top Secret secret
      230. 'MOD dcr: a Top Secret secret
      231. waitinput
      232. END
      233. FloatMaths:
      234. proc sgn :parameters x!
      235. ' Signum-Funktion: -1,0,+1
      236. return (x!>0)-(x!<0)
      237. endproc
      238. proc floor :parameters x!
      239. ' Gaussklammer-Funktion
      240. case abs(x!)<(10^-35):return 0
      241. case x!>0:return intf(x!)
      242. return (abs(x!-intf(x!)) < 10^-35)-intf(abs(x!-1))
      243. endproc
      244. proc ceil :parameters x!
      245. ' Ceiling-Funktion
      246. return -1*floor(-1*x!)
      247. endproc
      248. proc modf :parameters x!,y!
      249. ' Q: https://de.wikipedia.org/wiki/Modulo
      250. case abs(x!)<10^-35:return 0
      251. case abs(y!)<10^-35:return x!
      252. return sgn(y!)*abs(x!-y!*floor(x!/y!))
      253. endproc
      254. proc remn :parameters x!,y!
      255. ' Q: https://de.wikipedia.org/wiki/Modulo = Remnant()
      256. case abs(x!)<(10^-35):return 0
      257. case abs(y!)<(10^-35):return x!
      258. return sgn(x!)*abs(x!-y!*floor(x!/y!))
      259. endproc
      260. proc IsNeg :parameters x!
      261. return byte(Addr(x!),7)&%10000000>>7
      262. endproc
      263. proc frac :parameters x!
      264. var s!=sgn(x!)
      265. x!=abs(x!)
      266. x!=x!-round(x!,0)
      267. case x!<0:x!=1+x!
      268. return s!*x!
      269. endproc
      270. proc intf :parameters x!
      271. var s!=sgn(x!)
      272. x!=abs(x!)
      273. x!=x!-frac(x!)
      274. return s!*x!
      275. endproc
      276. GOTO "START"
      277. ProgEnd
      Alles anzeigen

      Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von p. specht ()

    • Quellcode

      1. WindowTitle "Experimentelle Float-Integer- und Fraction-Funktion"
      2. CLS:font 1:set("DECIMALS",15):declare x!
      3. Repeat
      4. print "\n x = ";:input x!
      5. print " ";format$("%g",INTf(x!))
      6. print " ";format$("%g",FRAC(x!))
      7. :if %csrlin>20:waitinput:cls:endif
      8. Until 0
      9. Proc INTf :parameters x!
      10. var dmls&=get("DECIMALS"):set("DECIMALS",17)
      11. var x$=str$(x!):set("DECIMALS",dmls&)
      12. return val(substr$(x$,1,"."))
      13. Endproc
      14. Proc FRAC :parameters x!
      15. var dmls&=get("DECIMALS"):set("DECIMALS",17)
      16. var x$=str$(x!):set("DECIMALS",dmls&)
      17. return x!-val(substr$(x$,1,"."))
      18. endproc
      Alles anzeigen
    • Zur Genauigkeit von Float-Variablen: In den meisten Programmiersprachen werden bei Double precision floating point = 11+53 bit Darstellung in den 8 Byte einer Float-Variablen, umgerechnet auf Dezimalstellen ungefähr 15-16, selten 17 Stellen genau dargestellt. Leider gehen neben Kommensurabilitätsfehlern (prinzipiellen Unverträglichkeiten zwischen Zahlensysstemen) auch verstärkt Rundungsfehler (insb. bei Divisionen) und Fehlerkummulation (bei Subtraktionen) in die Ungenauigkeit ein. Im Allgemeinen darf man in der Technik aber ohnehin auf 4 oder 5 genaue Stellen kürzen, da Messfehler physikalisch ohnehin schon größer sind, z.B. durch Wärme-bedingte Ausdehnung etc.
    • Abt. INHALTSVERZEICHNIS der bisherigen ALGORITHMEN-Kapitel
      ================================================
      gibt´s upgedated HIER wieder zum DOWNLOAD. In der ZIP enthalten ist die Datenbank als XProfan-EXE und der BEAMER als prf-Profandatei, den man an eigene Browserpfade anpassen kann, um rasch in die Nähe des gewünschten Beitrags geführt zu werden. Eingabebeispiel: Aufruf des Beitrags 121 in ALGORITHMEN-Kapitel 24: "24_121" eingeben - Internetseite geht auf, Beamer beendet sich. AVIRA Cloud sagt derzeit, alles sei sicher.
    • Abt. Test, ob Ascii2Hex wirklich die Inversion von Hex2Ascii liefert
      ===========================================
      Chr$(7) wurde ausgeblendet, um das ständige irritierende "Klingel"-Geräusch zu verhindern. Beide Programme verarbeiten und erzeugen Strings.
      Gruss

      Quellcode

      1. Cls
      2. Proc Ascii2Hex :parameters s$
      3. Declare i&,Ascii2Hex$
      4. Ascii2Hex$=""
      5. Whileloop len(s$):i&=&Loop
      6. Ascii2Hex$=Ascii2Hex$+Right$("0"+hex$(Ord(mid$(s$,i&,1))),2)
      7. Endwhile
      8. return Ascii2Hex$
      9. EndProc
      10. Proc Hex2Ascii :parameters h$
      11. Declare i&,Hex2Ascii$
      12. Hex2Ascii$=""
      13. Whileloop 0,len(h$)-1,2:i&=&Loop
      14. Hex2Ascii$=Hex2Ascii$+chr$(val("$"+mid$(h$,i&+1,2)))
      15. Endwhile
      16. return Hex2Ascii$
      17. EndProc
      18. TEST:
      19. font 1
      20. declare x&,y&,z$,h$
      21. Whileloop 0,255:x&=&Loop:case x&=7:x&=6
      22. whileloop 0,255:y&=&Loop:case y&=7:y&=6
      23. z$=ascii2hex(chr$(x&)+chr$(y&)+chr$(x&)+chr$(y&))
      24. h$=Hex2Ascii(z$)
      25. print x&,y&,z$;" ";tab(19);len(h$),">";h$;"<",ord(left$(h$,1)),ord(right$(h$,1))
      26. ifnot (chr$(x&)+chr$(y&)+chr$(x&)+chr$(y&)) = h$
      27. sound 2000,20
      28. waitinput
      29. endif
      30. endwhile
      31. endwhile
      32. waitinput
      Alles anzeigen
    • Abt. Rosetta Code: Best Shuffle
      ====================
      von BBC-BASIC nach XProfan-11.2a portiert, mittels zusätzlicher FNSwap()-Funktion.
      Gruss

      Quellcode

      1. WindowTitle "Rosetta Code: BEST SHUFFLE"
      2. 'Q: http://rosettacode.org/wiki/Best_shuffle
      3. WindowStyle 24:CLS:Font 1:print
      4. 'NO RANDOMIZE COMMAND!!!
      5. Declare a$,b$
      6. a$="abracadabra":Shuffleprint
      7. a$="seesaw" :Shuffleprint
      8. a$="elk" :Shuffleprint
      9. a$="grrrrrr" :Shuffleprint
      10. a$="up" :Shuffleprint
      11. a$="a" :Shuffleprint
      12. Waitinput
      13. End
      14. Proc FNshuffle: parameters s$
      15. Declare i%,j%,l%,t$
      16. t$=s$:l%=LEN(t$)
      17. Whileloop l%:i%=&Loop
      18. FNSwap(t$,i%,RND(l%)+1)
      19. Endwhile
      20. Whileloop l%:i%=&Loop
      21. Whileloop l%:j%=&Loop:case j%=i%:continue
      22. IF substr$(t$,i%)<>substr$(s$,j%)
      23. IF substr$(s$,i%)<>substr$(t$,j%)
      24. t$=FNSwap(t$,i%,j%)
      25. BREAK 'exit inner loop
      26. Endif
      27. ENDIF
      28. endwhile
      29. EndWhile
      30. return t$
      31. Endproc
      32. Proc FNsame :parameters s$,t$
      33. declare n%
      34. Whileloop LEN(s$)
      35. case MID$(s$,&Loop,1)=MID$(t$,&Loop,1):inc n%
      36. EndWhile
      37. return " ("+STR$(n%)+")"
      38. EndProc
      39. Proc FNSwap :parameters s$,i%,j%
      40. declare x$,y$
      41. x$=substr$(s$,i%):y$=substr$(s$,j%)
      42. s$=del$(s$,i%,1):s$=ins$(y$,s$,i%)
      43. s$=del$(s$,j%,1):s$=ins$(x$,s$,j%)
      44. return s$
      45. EndProc
      46. Proc ShufflePrint
      47. b$=FNshuffle(a$):PRINT " ",a$,tab(15);"->",b$,tab(30);FNsame(a$,b$)
      48. Endproc
      Alles anzeigen
    • Abt. FGS-02 ´Jacke´
      ==============
      Der Inhaber einer Innenstadt-Boutique will den optimalen Verkaufspreis für eine Sportjacke bestimmen. Die Erwartung des Herstellers manifestiert sich im UVP (Unverbindlich empfohlener Verkaufspreis) bei erwarteten 100 Verkäufen zu 75 Euro, und erfahrungsgemäß sind bei diesem Kundenkreis pro 5 Euro mehr 20 Verkäufe weniger sind zu erwarten, umgekehrt bei einer Preissenkung pro 5 Euro weniger 20 Verkäufe mehr. Im Einkauf kostet die Jacke 30 Euro. Welchen Preis sollte der Inhaber in der Hochsaison verlangen, um seinen Gewinn zu optimieren?
    • Abt. Nerd-Geometrie
      ==============
      <klugscheiß on>Ein Kreis wird von einer beliebigen Geraden geschnitten. Meist ist der Kreis nun in einen größeren Teil und einen kleineren Teil getrennt. Die enstandenen Schnittpunkte werden wir gleich brauchen.

      Wir wählen irgend einen Punkt auf dem größeren Kreisumfangsstück, und ziehen von dort zu den vor-erwähnten Schnittpunkten zwei Geraden. Interessanter Weise ist es egal, welchen Punkt am größeren Kreisumfangsstück man wählt: Der Winkel zwischen den zugehörigen Geraden zu den beiden Schnittpunkten bleibt immer gleich! Man kann ihn z.B. aus dem Abstand a des Kreismittelpunktes von der einleitend erwähnten schneidenden Geraden relativ einfach ermitteln: Er beträgt w = 2 * arctan( (R-a)/Sqrt(R^2 - a^2). R ist der Kreisradius, eh klar.

      Noch etwas ist interessant: Wählt man einen beliebigen Punkt auf dem kleineren Kreisumfangstück, dann entsteht bei der gleichen Konstruktion ein Winkel, der w2 = 180° - w beträgt. Man kann ihn aber auch per Formel errechnen zu w2 = 2 * arctan( (R + a)/Sqrt(R^2 - a^2). Das Plus oben ist der einzige Unterschied bei den Formeln.<klugscheiß off>
    • Zu FGS-02 ´Jacke´

      Ist zwar nicht die Lösung, aber die Praxis:

      Der Inhaber einer Innenstadt-Boutique schaut sich die Preise der Konkurrenz an und unterbietet den Preis.

      Wenn die Konkurrenz 75€ verlangt, ist der Preis nur 74,99€.

      Oder man streicht den UVP (UVP*1,1) durch und schreibt 10% Rabatt hin.
      - Bei Teppichen sind Rabatte > 50% normal.

      Tschau
    • Hinweis zu FGS-02:
      --------------------
      Gewinn = Verkaufsumsatz - Einkaufskosten =
      Gewinn = Preis * Menge - Einzelstückkosten * Menge =
      = (Preis - Einzelstückkosten) * Menge =
      = (75-5*Faktor - 30) * (100 + 20*Faktor) =
      = (45 - 5 * Faktor ) * (100 + 20*Faktor) =
      = 4500 - 500 * F + 20*45 * F - 5*20*F^2 =
      Gewinnfunktion = 4500 + 400 * F - 100 * F^2

      Im Optimalpunkt ist keine Gewinnsteigerung mehr möglich. Diese Aussage
      ist gleichbedeutend damit, dass der Anstieg (= die 1. Ableitung) der
      obigen Gewinnfunktion gleich Null ist. M.a.W., wir setzen
      4500 + 400 * F - 100*F^2
      ins Verhältnis zu einer kleinen Änderung von F und sehen:

      4500 und dF ?: Da tut sich garnix, also vergiss 4500,
      400 * F zu dF gibt 400, sowie
      -100*F^2 zu dF gibt -100*2*F = -200*F
      ---------------------------------------
      Im Optimalpunkt gilt also
      400-200*F = 0, und das bedeutet
      400 = 200*F, bzw. der Faktor
      F = 2.
      Den kann man nun in die Preisformel
      75 - 5*F einsetzen, und erhält den optimalen Verkaufspreis.

      Zusatzfrage: Mit wieviel Gewinn ist dann zu rechnen?


      Hinweis zu FGS-03:
      Da es stets um die Einerstelle geht, wo man nicht auf Übertrag
      achten muss, kommt man mit dem Kleinen 1 x 1 aus!

      Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von p. specht ()

    • Der Laden gehört dem Verkäufer selber und er hat kein Personal sondern betreibt den alleine!
      :lol:

      Meine Lösung:

      Abt. FGS-02 ´Jacke´
      ==============
      Der Inhaber einer Innenstadt-Boutique will den optimalen Verkaufspreis für eine Sportjacke bestimmen. Die Erwartung des Herstellers manifestiert sich im UVP (Unverbindlich empfohlener Verkaufspreis) bei erwarteten 100 Verkäufen zu 75 Euro, und erfahrungsgemäß sind bei diesem Kundenkreis pro 5 Euro mehr 20 Verkäufe weniger sind zu erwarten, umgekehrt bei einer Preissenkung pro 5 Euro weniger 20 Verkäufe mehr. Im Einkauf kostet die Jacke 30 Euro. Welchen Preis sollte der Inhaber in der Hochsaison verlangen, um seinen Gewinn zu optimieren?

      Gewinn G = VK-Preis (Pvk) * VK-Zahl (Zvk) - Einkaufskosten (=30 * Zvk)
      "20 VK weniger je 5 € mehr" grenzt den Suchraum ein, den bei +25 wäre der VK 0.
      Für Schrittweite 5 [€] ergibt sich für den Raum Pvk 75 bis 100

      Plus€ > Zvk
      (25 > 0)
      20 > 20
      15 > 40
      10 > 60
      5 > 80
      0 > 100
      5 Schritte, daher gehe ich auch mal 5 in die andere Richtung:
      minus€ > Zvk
      -5 > 120
      -10 > 140
      -15 > 160
      -20 > 180
      -25 > 200
      oder in Formeln:

      Pvk = 100 + x*(+/-)5 |für x = (+/-)0 bis 5

      Zvk = 100 + x*(+/-)20 |für x = (+/-)0 bis 5

      Der Gesamt-Einkaufspreis Pek folgt daraus mit:
      Pek = Zvk * 30

      Der Gewinn G ergibt sich damit nach der Formel
      G = Pvk*Zvk - Pek = (100 + x*(+/-)5)*(100 + x*(+/-)20) - (100 + x*(+/-)20)*30
      (für x = (+/-)0 bis 5)

      x Pvk Zvk Pek G
      5 125 .0 ..0 ...0
      4 120 20 600 1800
      3 115 40 1200 3400
      2 110 60 1800 4800
      1 105 80 2400 6000
      0 100 100 3000 7000
      -1 95 120 3600 7800
      -2 90 140 4200 8400
      -3 85 160 4800 8800
      -4 80 180 5400 9000
      -5 75 200 6000 9000

      Interessant: Bei Pvk 80 und 75 bleibt der G gleich.
      Also habe ich x noch mal bis -10 erweitert, um zu sehen, wie es weiter geht... Ergebnis wie erwartet:

      x Pvk Zvk .Pek ...G
      -6 70 220 6600 8800
      -7 65 240 7200 8400
      -8 60 260 7800 7800
      -9 55 280 8400 7000
      -10 50 300 9000 6000

      Unter Pvk 75,- sinkt der Gewinn wieder.

      Und damit kommen wir zur Antwort:
      Frage: Welchen Preis sollte der Inhaber in der Hochsaison verlangen, um seinen Gewinn zu optimieren?

      Antwort: Maximalen Gewinn würde er mit einem Verkaufspreis von 80 oder auch 75 € machen. Er sollte also 75 € verlangen (weil ein niedriger Preis besser aussieht und mehr Kunden anzieht!)

      Zusatzfrage: Mit wieviel Gewinn ist dann zu rechnen?
      Antwort: Er kann mit 9000 € Gewinn rechnen.

      Rabe
      Computer setzen logisches Denken fort!
      Unlogisches auch....

      Dieser Beitrag wurde bereits 7 mal editiert, zuletzt von ravenheart ()